mihari 5.6.2 → 5.7.1

data/lib/mihari/web/endpoints/ip_addresses.rb

@@ -1,24 +1,44 @@
 # frozen_string_literal: true
 
 module Mihari
-  module Endpoints
-    class IPAddresses < Grape::API
-      namespace :ip_addresses do
-        desc "Get an IP address", {
-          success: Entities::IPAddress,
-          failure: [{ code: 404, message: "Not found", model: Entities::Message }],
-          summary: "Get an IP address"
-        }
-        params do
-          requires :ip, type: String, regexp: /\A[0-9.]+\z/
+  module Web
+    module Endpoints
+      #
+      # IP address API endpoint
+      #
+      class IPAddresses < Grape::API
+        class IPGetter < Service
+          #
+          # @param [String] ip
+          #
+          # @return [Mihari::Structs::IPInfo::Response]
+          #
+          def call(ip)
+            Mihari::Enrichers::IPInfo.new.call ip
+          end
         end
-        get "/:ip", requirements: { ip: %r{[^/]+} } do
-          ip = params[:ip].to_s
 
-          data = Enrichers::IPInfo.new.query(ip)
-          error!({ message: "IP:#{ip} is not found" }, 404) if data.nil?
+        namespace :ip_addresses do
+          desc "Get an IP address", {
+            success: Entities::IPAddress,
+            failure: [{ code: 404, message: "Not found", model: Entities::Message }],
+            summary: "Get an IP address"
+          }
+          params do
+            requires :ip, type: String, regexp: /\A[0-9.]+\z/
+          end
+          get "/:ip", requirements: { ip: %r{[^/]+} } do
+            ip = params[:ip].to_s
+            result = IPGetter.result(ip)
+            return present(result.value!, with: Entities::IPAddress) if result.success?
 
-          present data, with: Entities::IPAddress
+            failure = result.failure
+            case failure
+            when Mihari::StatusCodeError
+              error!({ message: "ID:#{id} is not found" }, 404) if failure.status_code == 404
+            end
+            raise failure
+          end
         end
       end
     end

data/lib/mihari/web/endpoints/rules.rb

@@ -1,224 +1,273 @@
 # frozen_string_literal: true
 
 module Mihari
-  module Endpoints
-    class Rules < Grape::API
-      namespace :rules do
-        desc "Get Rule IDs", {
-          is_array: true,
-          success: Entities::RuleIDs,
-          summary: "Get rule IDs"
-        }
-        get "/ids" do
-          rule_ids = Mihari::Models::Rule.distinct.pluck(:id)
-          present({ rule_ids: rule_ids }, with: Entities::RuleIDs)
-        end
+  module Web
+    module Endpoints
+      #
+      # Rule API endpoint
+      #
+      class Rules < Grape::API
+        class RuleSearcher < Mihari::Service
+          class ResultValue
+            # @return [Array<Mihari::Models::Rule>]
+            attr_reader :rules
+
+            # @return [Integer]
+            attr_reader :total
+
+            # @return [Mihari::Structs::Filters::Rule::SearchFilterWithPagination]
+            attr_reader :filter
+
+            #
+            # @param [Array<Mihari::Models::Rule>] rules
+            # @param [Integer] total
+            # @param [Mihari::Structs::Filters::Rule::SearchFilterWithPagination] filter
+            #
+            def initialize(rules:, total:, filter:)
+              @rules = rules
+              @total = total
+              @filter = filter
+            end
+          end
 
-        desc "Search rules", {
-          is_array: true,
-          success: Entities::RulesWithPagination,
-          failure: [{ code: 404, message: "Not found", model: Entities::Message }],
-          summary: "Search rules"
-        }
-        params do
-          optional :page, type: Integer, default: 1
-          optional :limit, type: Integer, default: 10
-
-          optional :title, type: String
-          optional :description, type: String
-          optional :tag, type: String
-
-          optional :fromAt, type: DateTime
-          optional :toAt, type: DateTime
+          #
+          # @params [Hash]
+          #
+          # @return [ResultValue]
+          #
+          def call(params)
+            filter = params.to_h.to_snake_keys
+
+            # normalize keys
+            filter["tag_name"] = filter["tag"]
+            # symbolize hash keys
+            filter = filter.to_h.symbolize_keys
+
+            search_filter_with_pagination = Mihari::Structs::Filters::Rule::SearchFilterWithPagination.new(**filter)
+            rules = Mihari::Models::Rule.search(search_filter_with_pagination)
+            total = Mihari::Models::Rule.count(search_filter_with_pagination.without_pagination)
+
+            ResultValue.new(rules: rules, total: total, filter: filter)
+          end
         end
-        get "/" do
-          filter = params.to_h.to_snake_keys
-
-          # normalize keys
-          filter["tag_name"] = filter["tag"]
-          # symbolize hash keys
-          filter = filter.to_h.symbolize_keys
-
-          search_filter_with_pagenation = Structs::Filters::Rule::SearchFilterWithPagination.new(**filter)
-          rules = Mihari::Models::Rule.search(search_filter_with_pagenation)
-          total = Mihari::Models::Rule.count(search_filter_with_pagenation.without_pagination)
-
-          present(
-            { rules: rules,
-              total: total,
-              current_page: filter[:page].to_i,
-              page_size: filter[:limit].to_i },
-            with: Entities::RulesWithPagination
-          )
+
+        class RuleGetter < Service
+          #
+          # @params [String] id
+          #
+          # @return [Mihari::Models::Rule]
+          #
+          def call(id)
+            Mihari::Models::Rule.find id
+          end
         end
 
-        desc "Get a rule", {
-          success: Entities::Rule,
-          failure: [{ code: 404, message: "Not found", model: Entities::Message }],
-          summary: "Get a rule"
-        }
-        params do
-          requires :id, type: String
+        class RuleRunner < Service
+          #
+          # @param [String] id
+          #
+          def call(id)
+            rule = Mihari::Rule.from_model(Mihari::Models::Rule.find(id))
+            rule.call
+          end
         end
-        get "/:id" do
-          extend Dry::Monads[:result, :try]
 
-          id = params["id"].to_s
+        class RuleCreator < Service
+          #
+          # @params [String]
+          #
+          # @return [Mihari::Models::Rule]
+          #
+          def call(yaml)
+            rule = Rule.from_yaml(yaml)
 
-          result = Try do
-            Mihari::Models::Rule.find(id)
-          end.to_result
+            found = Mihari::Models::Rule.find_by_id(rule.id)
+            error!({ message: "ID:#{rule.id} is already registered" }, 400) unless found.nil?
 
-          return present(result.value!, with: Entities::Rule) if result.success?
+            rule.model.save
+            rule
+          end
+        end
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          else
-            raise failure
+        class RuleUpdater < Service
+          #
+          # @params [String] id
+          # @params [String] yaml
+          #
+          # @return [Mihari::Models::Rule]
+          #
+          def call(id:, yaml:)
+            Mihari::Models::Rule.find(id)
+
+            rule = Rule.from_yaml(yaml)
+            rule.model.save
+            rule
           end
         end
 
-        desc "Run a rule", {
-          success: Entities::Message,
-          summary: "Run a rule"
-        }
-        params do
-          requires :id, type: String
+        class RuleDestroyer < Service
+          #
+          # @param [String] id
+          #
+          def call(id)
+            Mihari::Models::Rule.find(id).destroy
+          end
         end
-        get "/:id/run" do
-          extend Dry::Monads[:result, :try]
 
-          id = params["id"].to_s
+        namespace :rules do
+          desc "Get Rule IDs", {
+            is_array: true,
+            success: Entities::RuleIDs,
+            summary: "Get rule IDs"
+          }
+          get "/ids" do
+            rule_ids = Mihari::Models::Rule.distinct.pluck(:id)
+            present({ rule_ids: rule_ids }, with: Entities::RuleIDs)
+          end
 
-          result = Try { Rule.from_model(Mihari::Models::Rule.find(id)) }.to_result
-          if result.success?
-            result.value!.analyzer.run
-            status 201
-            return present({ message: "ID:#{id} is ran successfully" }, with: Entities::Message)
+          desc "Search rules", {
+            is_array: true,
+            success: Entities::RulesWithPagination,
+            failure: [{ code: 404, message: "Not found", model: Entities::Message }],
+            summary: "Search rules"
+          }
+          params do
+            optional :page, type: Integer, default: 1
+            optional :limit, type: Integer, default: 10
+            optional :title, type: String
+            optional :description, type: String
+            optional :tag, type: String
+            optional :fromAt, type: DateTime
+            optional :toAt, type: DateTime
+          end
+          get "/" do
+            value = RuleSearcher.call(params.to_h)
+            present({
+              rules: value.rules,
+              total: value.total,
+              current_page: value.filter[:page].to_i,
+              page_size: value.filter[:limit].to_i
+            },
+              with: Entities::RulesWithPagination)
           end
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          else
-            raise failure
+          desc "Get a rule", {
+            success: Entities::Rule,
+            failure: [{ code: 404, message: "Not found", model: Entities::Message }],
+            summary: "Get a rule"
+          }
+          params do
+            requires :id, type: String
           end
-        end
+          get "/:id" do
+            id = params[:id].to_s
+            result = RuleGetter.result(params[:id].to_s)
+            return present(result.value!, with: Entities::Rule) if result.success?
 
-        desc "Create a rule", {
-          success: Entities::Rule,
-          summary: "Create a rule"
-        }
-        params do
-          requires :yaml, type: String, documentation: { param_type: "body" }
-        end
-        post "/" do
-          extend Dry::Monads[:result, :try]
-
-          yaml = params[:yaml]
-          result = Try { Rule.from_yaml(yaml) }.to_result.bind do |rule|
-            Try do
-              found = Mihari::Models::Rule.find_by_id(rule.id)
-              error!({ message: "ID:#{rule.id} is already registered" }, 400) unless found.nil?
-              rule
-            end.to_result
-          end.bind do |rule|
-            Try do
-              rule.model.save
-              rule
-            end.to_result
-          end
-
-          if result.success?
-            status 201
-            return present(result.value!.model, with: Entities::Rule)
-          end
-
-          failure = result.failure
-          case failure
-          when Psych::SyntaxError
-            error!({ message: failure.message }, 400)
-          when ValidationError
-            error!({ message: "Data format is invalid", details: failure.errors.to_h }, 400)
-          else
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            end
             raise failure
           end
-        end
-
-        desc "Update a rule", {
-          success: Entities::Rule,
-          summary: "Update a rule"
-        }
-        params do
-          requires :id, type: String, documentation: { param_type: "body" }
-          requires :yaml, type: String, documentation: { param_type: "body" }
-        end
-        put "/" do
-          extend Dry::Monads[:result, :try]
 
-          id = params[:id]
-          yaml = params[:yaml]
+          desc "Run a rule", {
+            success: Entities::Message,
+            summary: "Run a rule"
+          }
+          params do
+            requires :id, type: String
+          end
+          get "/:id/run" do
+            id = params[:id].to_s
+            result = RuleRunner.result(id)
+            if result.success?
+              status 201
+              return present({ message: "ID:#{id}} ran successfully" }, with: Entities::Message)
+            end
 
-          result = Try do
-            Mihari::Models::Rule.find(id)
-          end.to_result.bind do |_|
-            Try { Rule.from_yaml(yaml) }.to_result
-          end.bind do |rule|
-            Try do
-              rule.model.save
-              rule
-            end.to_result
-          end
-
-          if result.success?
-            status 201
-            return present(result.value!.model, with: Entities::Rule)
-          end
-
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          when Psych::SyntaxError
-            error!({ message: failure.message }, 400)
-          when ValidationError
-            error!({ message: "Data format is invalid", details: failure.errors.to_h }, 400)
-          else
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            end
             raise failure
           end
-        end
 
-        desc "Delete a rule", {
-          success: Entities::Message,
-          failure: [{ code: 404, message: "Not found", model: Entities::Message }],
-          summary: "Delete a rule"
-        }
-        params do
-          requires :id, type: String
-        end
-        delete "/:id" do
-          extend Dry::Monads[:result, :try]
+          desc "Create a rule", {
+            success: Entities::Rule,
+            summary: "Create a rule"
+          }
+          params do
+            requires :yaml, type: String, documentation: { param_type: "body" }
+          end
+          post "/" do
+            result = RuleCreator.result(params[:yaml])
+            if result.success?
+              status 201
+              return present(result.value!.model, with: Entities::Rule)
+            end
 
-          id = params["id"].to_s
+            failure = result.failure
+            case failure
+            when Psych::SyntaxError
+              error!({ message: failure.message }, 400)
+            when ValidationError
+              error!({ message: "Rule format is invalid", details: failure.errors.to_h }, 400)
+            end
+            raise failure
+          end
 
-          result = Try do
-            rule = Mihari::Models::Rule.find(id)
-            rule.destroy
-          end.to_result
+          desc "Update a rule", {
+            success: Entities::Rule,
+            summary: "Update a rule"
+          }
+          params do
+            requires :id, type: String, documentation: { param_type: "body" }
+            requires :yaml, type: String, documentation: { param_type: "body" }
+          end
+          put "/" do
+            id = params[:id].to_s
+            result = RuleUpdater.result(id: id, yaml: params[:yaml].to_s)
+            if result.success?
+              status 201
+              return present(result.value!.model, with: Entities::Rule)
+            end
+
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            when Psych::SyntaxError
+              error!({ message: failure.message }, 400)
+            when ValidationError
+              error!({ message: "Rule format is invalid", details: failure.errors.to_h }, 400)
+            end
+            raise failure
+          end
 
-          if result.success?
-            status 204
-            return present({ message: "ID:#{id} is deleted" }, with: Entities::Message)
+          desc "Delete a rule", {
+            success: Entities::Message,
+            failure: [{ code: 404, message: "Not found", model: Entities::Message }],
+            summary: "Delete a rule"
+          }
+          params do
+            requires :id, type: String
           end
+          delete "/:id" do
+            id = params[:id].to_s
+            result = RuleDestroyer.result(id)
+            if result.success?
+              status 204
+              return present({ message: "ID:#{id} is deleted" }, with: Entities::Message)
+            end
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          else
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            end
             raise failure
           end
         end

data/lib/mihari/web/endpoints/tags.rb

@@ -1,46 +1,53 @@
 # frozen_string_literal: true
 
 module Mihari
-  module Endpoints
-    class Tags < Grape::API
-      namespace :tags do
-        desc "Get tags", {
-          is_array: true,
-          success: Entities::Tags,
-          summary: "Get tags"
-        }
-        get "/" do
-          tags = Mihari::Models::Tag.distinct.pluck(:name)
-          present({ tags: tags }, with: Entities::Tags)
-        end
-
-        desc "Delete a tag", {
-          success: Entities::Message,
-          failure: [{ code: 404, message: "Not found", model: Entities::Message }],
-          summary: "Delete a tag"
-        }
-        params do
-          requires :name, type: String
+  module Web
+    module Endpoints
+      #
+      # Tag API endpoint
+      #
+      class Tags < Grape::API
+        class TagDestroyer < Service
+          #
+          # @param [Integer] id
+          #
+          def call(id)
+            Mihari::Models::Tag.find(id).destroy
+          end
         end
-        delete "/:name" do
-          extend Dry::Monads[:result, :try]
 
-          name = params[:name].to_s
-
-          result = Try do
-            Mihari::Models::Tag.where(name: name).destroy_all
-          end.to_result
+        namespace :tags do
+          desc "Get tags", {
+            is_array: true,
+            success: Entities::Tags,
+            summary: "Get tags"
+          }
+          get "/" do
+            tags = Mihari::Models::Tag.distinct.pluck(:name)
+            present({ tags: tags }, with: Entities::Tags)
+          end
 
-          if result.success?
-            status 204
-            return present({ message: "" }, with: Entities::Message)
+          desc "Delete a tag", {
+            success: Entities::Message,
+            failure: [{ code: 404, message: "Not found", model: Entities::Message }],
+            summary: "Delete a tag"
+          }
+          params do
+            requires :id, type: Integer
           end
+          delete "/:id" do
+            id = params[:id].to_i
+            result = TagDestroyer.result(id)
+            if result.success?
+              status 204
+              return present({ message: "" }, with: Entities::Message)
+            end
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "Name:#{name} is not found" }, 404)
-          else
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            end
             raise failure
           end
         end

data/lib/mihari/web/middleware/connection_adapter.rb

@@ -1,15 +1,22 @@
+# frozen_string_literal: true
+
 module Mihari
-  module Middleware
-    class ConnectionAdapter
-      def initialize(app)
-        @app = app
-      end
+  module Web
+    module Middleware
+      #
+      # DB connection adapter for Rack app
+      #
+      class ConnectionAdapter
+        def initialize(app)
+          @app = app
+        end
 
-      def call(env)
-        Mihari::Database.with_db_connection do
-          status, headers, body = @app.call(env)
+        def call(env)
+          Mihari::Database.with_db_connection do
+            status, headers, body = @app.call(env)
 
-          [status, headers, body]
+            [status, headers, body]
+          end
         end
       end
     end