mihari 5.6.1 → 5.7.0

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

@@ -1,24 +1,29 @@
 # 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/
-        end
-        get "/:ip", requirements: { ip: %r{[^/]+} } do
-          ip = params[:ip].to_s
+  module Web
+    module Endpoints
+      #
+      # IP address API endpoint
+      #
+      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/
+          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?
+            data = Enrichers::IPInfo.new.call(ip)
+            error!({ message: "IP:#{ip} is not found" }, 404) if data.nil?
 
-          present data, with: Entities::IPAddress
+            present data, with: Entities::IPAddress
+          end
         end
       end
     end

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

@@ -1,232 +1,230 @@
 # 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::Rule.distinct.pluck(:id)
-          present({ rule_ids: rule_ids }, with: Entities::RuleIDs)
-        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
-        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::Rule.search(search_filter_with_pagenation)
-          total = Mihari::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
-          )
-        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
-        end
-        get "/:id" do
-          extend Dry::Monads[:result, :try]
-
-          id = params["id"].to_s
-
-          result = Try do
-            Mihari::Rule.find(id)
-          end.to_result
+  module Web
+    module Endpoints
+      #
+      # Rule API endpoint
+      #
+      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
 
-          return present(result.value!, with: Entities::Rule) if result.success?
+          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
+            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
+            )
+          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
+            extend Dry::Monads[:result, :try]
 
-        desc "Run a rule", {
-          success: Entities::Message,
-          summary: "Run a rule"
-        }
-        params do
-          requires :id, type: String
-        end
-        get "/:id/run" do
-          extend Dry::Monads[:result, :try]
+            id = params["id"].to_s
 
-          id = params["id"].to_s
+            result = Try do
+              Mihari::Models::Rule.find(id)
+            end.to_result
 
-          result = Try do
-            Mihari::Services::RuleProxy.from_model(Mihari::Rule.find(id))
-          end.to_result
+            return present(result.value!, with: Entities::Rule) if result.success?
 
-          if result.success?
-            result.value!.analyzer.run
-            status 201
-            return present({ message: "ID:#{id} is ran successfully" }, with: Entities::Message)
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            else
+              raise failure
+            end
           end
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          else
-            raise failure
+          desc "Run a rule", {
+            success: Entities::Message,
+            summary: "Run a rule"
+          }
+          params do
+            requires :id, type: String
           end
-        end
-
-        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 do
-            Services::RuleProxy.from_yaml(yaml)
-          end.to_result.bind do |rule|
-            Try do
-              found = Mihari::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
+          get "/:id/run" do
+            extend Dry::Monads[:result, :try]
+
+            id = params["id"].to_s
+
+            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)
+            end
+
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "ID:#{id} is not found" }, 404)
+            else
+              raise failure
+            end
           end
 
-          if result.success?
-            status 201
-            return present(result.value!.model, with: Entities::Rule)
+          desc "Create a rule", {
+            success: Entities::Rule,
+            summary: "Create a rule"
+          }
+          params do
+            requires :yaml, type: String, documentation: { param_type: "body" }
           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
-            raise failure
+          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
+              raise failure
+            end
           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]
-
-          result = Try do
-            Mihari::Rule.find(id)
-          end.to_result.bind do |_|
-            Try do
-              Services::RuleProxy.from_yaml(yaml)
-            end.to_result
-          end.bind do |rule|
-            Try do
-              rule.model.save
-              rule
-            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
-
-          if result.success?
-            status 201
-            return present(result.value!.model, with: Entities::Rule)
+          put "/" do
+            extend Dry::Monads[:result, :try]
+
+            id = params[:id]
+            yaml = params[:yaml]
+
+            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
+              raise failure
+            end
           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
-            raise failure
+          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
-        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]
-
-          id = params["id"].to_s
+          delete "/:id" do
+            extend Dry::Monads[:result, :try]
 
-          result = Try do
-            rule = Mihari::Rule.find(id)
-            rule.destroy
-          end.to_result
+            id = params["id"].to_s
 
-          if result.success?
-            status 204
-            return present({ message: "ID:#{id} is deleted" }, with: Entities::Message)
-          end
+            result = Try do
+              rule = Mihari::Models::Rule.find(id)
+              rule.destroy
+            end.to_result
 
-          failure = result.failure
-          case failure
-          when ActiveRecord::RecordNotFound
-            error!({ message: "ID:#{id} is not found" }, 404)
-          else
-            raise failure
+            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
+              raise failure
+            end
           end
         end
       end

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

@@ -1,47 +1,52 @@
 # 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::Tag.distinct.pluck(:name)
-          present({ tags: tags }, with: Entities::Tags)
-        end
+  module Web
+    module Endpoints
+      #
+      # Tag API endpoint
+      #
+      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
-        end
-        delete "/:name" do
-          extend Dry::Monads[:result, :try]
+          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
+          end
+          delete "/:name" do
+            extend Dry::Monads[:result, :try]
 
-          name = params[:name].to_s
+            name = params[:name].to_s
 
-          result = Try do
-            Mihari::Tag.where(name: name).destroy_all
-          end.to_result
+            result = Try do
+              Mihari::Models::Tag.where(name: name).destroy_all
+            end.to_result
 
-          if result.success?
-            status 204
-            return present({ message: "" }, with: Entities::Message)
-          end
+            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
-            raise failure
+            failure = result.failure
+            case failure
+            when ActiveRecord::RecordNotFound
+              error!({ message: "Name:#{name} is not found" }, 404)
+            else
+              raise failure
+            end
           end
         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

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

@@ -1,17 +1,24 @@
+# frozen_string_literal: true
+
 module Mihari
-  module Middleware
-    class ErrorNotificationAdapter
-      include Mixins::ErrorNotification
+  module Web
+    module Middleware
+      #
+      # Error notification adapter for Rack app
+      #
+      class ErrorNotificationAdapter
+        include Mixins::ErrorNotification
 
-      def initialize(app)
-        @app = app
-      end
+        def initialize(app)
+          @app = app
+        end
 
-      def call(env)
-        with_error_notification do
-          status, headers, body = @app.call(env)
+        def call(env)
+          with_error_notification do
+            status, headers, body = @app.call(env)
 
-          [status, headers, body]
+            [status, headers, body]
+          end
         end
       end
     end