gi_job 0.1.3

data/lib/generators/gi_job/install/templates/schemas/gi_job_files.schema

@@ -0,0 +1,11 @@
+create_table "gi_job_files", id: :bigint, unsigned: true, force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4" do |t|
+  t.references       "gi_job_transaction"
+  t.string           "division"
+  t.string           "name",               null: false
+  t.json             "file"
+  t.unsigned_integer "rows"
+  t.unsigned_bigint  "size"
+  t.timestamps
+end
+
+add_index "gi_job_files", ["gi_job_transaction_id"], name: "gi_job_files_ix1", using: :btree

data/lib/generators/gi_job/install/templates/schemas/gi_job_logs.schema

@@ -0,0 +1,10 @@
+create_table "gi_job_logs", id: :bigint, unsigned: true, force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4" do |t|
+  t.references       "gi_job_transaction"
+  t.integer          "level",          default: 100, null: false
+  t.integer          "position"
+  t.string           "division"
+  t.text             "description"
+  t.timestamps
+end
+
+add_index "gi_job_logs", ["gi_job_transaction_id", "level", "division"], name: "gi_job_logs_ix1", using: :btree

data/lib/generators/gi_job/install/templates/schemas/gi_job_transactions.schema

@@ -0,0 +1,18 @@
+create_table "gi_job_transactions", id: :bigint, unsigned: true, force: :cascade, options: "ENGINE=InnoDB DEFAULT CHARSET=utf8mb4" do |t|
+  t.references  "owner",             polymorphic: true
+  t.string      "name",              default: "-",          null: false
+  t.integer     "status",            default: 100,          null: false
+  t.integer     "counts_all"
+  t.integer     "counts_progress"
+  t.integer     "counts_completed"
+  t.integer     "counts_errord"
+  t.integer     "command",           default: 100,          null: false
+  t.text        "parameter"
+  t.string      "process_id"
+  t.integer     "process_status",    default: 100,          null: false
+  t.text        "process_progress"
+  t.timestamps
+end
+
+add_index "gi_job_transactions", ["owner_id", "owner_type", "name", "status"], name: "gi_job_transactions_ix1", using: :btree
+add_index "gi_job_transactions", ["updated_at"], name: "gi_job_transactions_ix2", using: :btree

data/lib/generators/gi_job/install/templates/uploaders/gi_log_file_carrier_wave_uploader.rb

@@ -0,0 +1,25 @@
+class GiLogFileCarrierWaveUploader < CarrierWave::Uploader::Base
+
+  def store_dir
+    "#{Rails.env}/uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # def extension_white_list
+  #   %w(txt csv)
+  # end
+
+  def filename
+    if original_filename.present?
+      "#{original_filename}"
+    end
+  end
+
+  def fog_public
+    false
+  end
+
+  def fog_authenticated_url_expiration
+    5.minutes
+  end
+
+end

data/lib/gi_job.rb

@@ -0,0 +1,32 @@
+require "gi_job/version"
+require "gi_job/jobs/job_utils"
+require "gi_job/jobs/job_command_suspended"
+require "gi_job/jobs/concerns/jobable"
+require "gi_job/models/concerns/gi_job_transactionable"
+require "gi_job/models/concerns/gi_job_loggable"
+require "gi_job/models/concerns/gi_job_fileable"
+require "gi_job/models/concerns/gi_job_ownerble"
+
+module GiJob
+  class Error < StandardError; end
+  # Your code goes here...
+
+  def self.logger
+    @logger ||= Rails::Logger.new($stdout, level: Rails::Logger::INFO)
+  end
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.run
+    puts "GiJob call run!!"
+    puts "aaa!"
+    puts "abc!"
+  end
+
+  class GiJobRailtie < Rails::Railtie
+    rake_tasks do
+      load 'gi_job/tasks/gi_job_task.rake'
+    end
+  end
+end

data/lib/gi_job/jobs/concerns/job_constructor.rb

@@ -0,0 +1,185 @@
+
+module GiJob
+  module Jobs
+    module Concerns
+      module JobConstructor
+
+        extend ActiveSupport::Concern
+
+        included do # begin included
+          #### job作成
+          def self.create_job(**args)
+            self.create_job_with(args)
+          end
+        end # end included
+
+
+        class_methods do # begin class_methods
+
+          def create_job_with(
+            owner: nil,
+            parameter: {},
+            gi_job_transaction_params: {},
+            option: {
+              create_only: false,
+              uploaded_file: nil,
+            }
+          )
+
+            # transactionレコード作成
+            gi_job_transaction = self.create_gi_job_transaction(
+              owner: owner,
+              parameter: parameter,
+              gi_job_transaction_params: gi_job_transaction_params,
+              option: option
+            )
+
+            if option[:create_only].present?
+              # 作成のみの場合はstartしない
+              return {gi_job_transaction: gi_job_transaction}
+            else
+              self.start_job_with(gi_job_transaction: gi_job_transaction)
+            end
+
+          end
+
+          def start_job_with(gi_job_transaction:)
+            # 前処理
+            # GiJob.logger.ap({message: "pre_process"})
+            result = job_process_call(process_name: "前処理", gi_job_transaction: gi_job_transaction) do |**args|
+              self.job_pre_process_impl(args)
+            end
+
+            if result.present? && result[:error].present?
+              # 前処理エラー
+              return {gi_job_transaction: gi_job_transaction}.merge(result)
+            end
+
+            # 本処理
+            # GiJob.logger.ap({message: "call_process"})
+            result = job_process_call(process_name: "呼出処理", gi_job_transaction: gi_job_transaction) do |**args|
+              self.job_call_process_impl(args)
+            end
+
+            return {gi_job_transaction: gi_job_transaction}.merge(result)
+          end
+
+          def create_gi_job_transaction(
+            owner: nil,
+            parameter: {},
+            gi_job_transaction_params: {},
+            option: {}
+          )
+            # GiJob.logger.ap({create_job_transaction: {owner: owner, parameter: parameter, gi_job_transaction_params: gi_job_transaction_params, option: option,}})
+
+            tmp_parameter = parameter.deep_dup
+
+            # jobレコードを作成
+            merged_params = ({
+              owner: owner,
+              name: "#{self.name.underscore}",
+              parameter: parameter.present? ? parameter.deep_symbolize_keys! : {},
+            }).merge(gi_job_transaction_params)
+            gi_job_transaction = GiJobTransaction.new(merged_params)
+            gi_job_transaction.save!
+            # GiJob.logger.ap(created: {gi_job_transaction: gi_job_transaction})
+
+            if option.has_key?(:uploaded_file) && option[:uploaded_file].present?
+              # uploaded_fileを保存
+              uploaded_file = option.delete(:uploaded_file)
+              gi_job_transaction.create_file!(uploaded_file: uploaded_file)
+            end
+
+            # # その他のadditional_infoを保存
+            # gi_job_transaction.update!(additional_info: tmp_additional_info)
+            #
+            # # master_jobを紐づけ
+            # self.relation_master_schedule_job!(gi_job_transaction, master_schedule_job)
+
+            gi_job_transaction
+
+          end
+
+          def job_process_call(process_name: nil, **args, &func)
+            # GiJob.logger.ap(process_name: process_name, args: args, func: func)
+            return_object = {error: nil, messages: [], result: nil}
+            begin
+              return_object = func.call(args)
+            rescue => e
+              GiJob.logger.fatal(e.message)
+              GiJob.logger.fatal(e.backtrace.join("\n"))
+              message = "#{process_name.present? ? "#{process_name}で" : ""}エラーが発生しました。エラーコード: #{e}"
+              return_object = {error: e, messages: [message], result: nil}
+            end
+
+            if return_object.present? && return_object[:error].present?
+              gi_job_transaction = args[:gi_job_transaction]
+              gi_job_transaction.status_error!
+              gi_job_transaction.append_log_error(
+                division: "#{self.name}",
+                description: "#{return_object[:messages].present? ? [return_object[:messages]].flatten.join(" ") : ""}"
+              )
+            end
+
+            return_object
+          end
+
+          def job_pre_process_impl(**args)
+            # 前処理が必要であれば派生クラスで拡張する事
+            # この処理は、同期/非同期に関わらず、同期処理で行われる。
+            # また、ジョブ再開時には再度呼び出しは行われない。
+            # エラーの場合は {error: true} とする事
+            {error: nil, messages: [], result: nil}
+          end
+
+          def job_call_process_impl(**args)
+            # 呼び出し処理の変更必要であれば派生クラスで拡張する事
+            # エラーの場合は {error: true} とする事
+            return self.job_call_process_default(args[:gi_job_transaction])
+          end
+
+          def job_call_process_default(gi_job_transaction)
+            # GiJob.logger.ap(job_call_process_default: {gi_job_transaction: gi_job_transaction})
+
+            # TODO 再開時にsuspendをnoneに変更する
+            JobUtils.check_job_suspended(gi_job_transaction)
+
+            application_job = nil
+            if gi_job_transaction.parameter[:_perform_now].present?
+              # 即時実行指定
+              application_job = perform_now({gi_job_transaction: gi_job_transaction})
+            else
+              application_job = perform_later({gi_job_transaction: gi_job_transaction})
+            end
+
+            {error: nil, messages: [], result: {application_job: application_job}}
+          end
+
+          def job_post_process_impl(**args)
+            # 後処理必要であれば派生クラスで拡張する事
+            # この処理は、同期/非同期にかかわらず、ジョブ終了後に呼び出される
+            # エラーの場合は {error: true} とする事
+            return self.job_post_process_default(args[:gi_job_transaction])
+          end
+
+          def job_post_process_default(gi_job_transaction)
+            if gi_job_transaction.parameter[:_one_shot].present?
+              # 単発ジョブ指定の場合は過去のjobを削除する
+              GiJobTransaction.delete_old_for_one_shot(gi_job_transaction)
+            end
+
+            {error: nil, messages: [], result: nil}
+          end
+
+
+
+          def aaa()
+          end
+
+        end # end class_methods
+
+
+      end # end GiJobable
+    end
+  end
+end

data/lib/gi_job/jobs/concerns/job_runner.rb

@@ -0,0 +1,549 @@
+
+module GiJob
+  module Jobs
+    module Concerns
+      module JobRunner
+
+        extend ActiveSupport::Concern
+
+        included do # begin included
+        end # end included
+
+        class_methods do # begin class_methods
+        end # end class_methods
+
+        ##################### job実行系
+
+        def perform(args)
+          set_signal_trap
+          perform_impl(args)
+        end
+
+        def perform_impl(**args)
+          _perform_default(args)
+        end
+
+        def _perform_default(**args)
+
+          @_gi_job_transaction = args[:gi_job_transaction]
+          # GiJob.logger.ap({_perform_default: {@_gi_job_transaction: @_gi_job_transaction}})
+
+          @_process_info = {
+            error: @_gi_job_transaction.counts_errord != nil && 0 < @_gi_job_transaction.counts_errord,
+            counts: {
+              all: @_gi_job_transaction.counts_all || 0,
+              progress: @_gi_job_transaction.counts_progress || 0,
+              completed: @_gi_job_transaction.counts_completed || 0,
+              errord: @_gi_job_transaction.counts_errord || 0,
+            }
+          }
+          # GiJob.logger.ap({_perform_default: {@_process_info: @_process_info}})
+
+
+          begin
+            run_job do
+
+              _suspendable = self.class.respond_to?(:GI_JOB_SUSPENDABLE) && self.class::GI_JOB_SUSPENDABLE
+              process_status_transaction(suspendable: _suspendable) do
+                run_job_impl(
+                  gi_job_transaction: @_gi_job_transaction,
+                  parameter: @_gi_job_transaction.parameter
+                )
+              end
+
+            end
+
+          rescue => e
+            JobUtils.logging_fatal(e)
+            @_gi_job_transaction.status_error!
+            @_gi_job_transaction.append_log(
+              level: :error,
+              division: "#{e.class.name}",
+              description: "処理中に内部エラーが発生しました。"
+            )
+          end
+
+        end
+
+        def run_job
+          # GiJob.logger.ap({run_job: {args: args}})
+
+          time_start = Time.zone.now
+          result = {}
+          begin
+            @_gi_job_transaction.status_running!
+            result = yield(@_gi_job_transaction)
+
+          rescue => e
+            GiJob.logger.fatal(e.message)
+            GiJob.logger.fatal(e.backtrace.join("\n"))
+            @_process_info[:error] = true
+            @_gi_job_transaction.status_error!
+            counts_progress = @_process_info[:counts][:progress]
+            message = "#{counts_progress}件目の処理で内部エラーが発生しました。"
+            @_gi_job_transaction.append_log(
+              level: :error,
+              division: "#{e.class.name}",
+              description: message,
+            )
+
+          end
+
+          GiJob.logger.ap({JOB: "done #{self.class.name}"})
+          if @_gi_job_transaction.process_status_suspended? || @_gi_job_transaction.status_ended?
+            # 以下の場合はステータスを変更しない
+            # - 途中でsuspendedが発生している場合
+            # - 途中で終了ステータスが設定されている場合
+
+          else
+            if @_process_info[:error]
+              @_gi_job_transaction.status_error!
+            else
+              @_gi_job_transaction.status_completed!
+            end
+          end
+
+          syms = @_process_info[:counts].keys
+          update_counts_by_process_info(syms)
+
+          _slack_notifire = self.class.respond_to?(:GI_JOB_SLACK_NOTIFIER) && self.class::GI_JOB_SLACK_NOTIFIER
+          if _slack_notifire && @_gi_job_transaction.parameter[:_dont_notify].blank?
+            # 通知
+            notifier_slack(gi_job_transaction: @_gi_job_transaction, time_start: time_start, result: result)
+          end
+
+          # 後処理
+          post_process_result = self.class.job_process_call(process_name: "後処理", gi_job_transaction: @_gi_job_transaction) do |**args|
+            self.class.job_post_process_impl(args)
+          end
+
+        end
+
+        def run_job_impl(gi_job_transaction:, parameter:)
+          # 派生クラスで拡張すること
+          GiJob.logger.warning("gi_job_transaction.id: #{gi_job_transaction.id}, ...not implemented run_job_imple in #{self.class.name}")
+        end
+
+
+        ################### counts系
+        def increment_counts(sym = :progress, threshold: 1)
+          @_process_info[:counts][sym] += 1
+
+          record_sym = "counts_#{sym.to_s}".to_sym
+          # GiJob.logger.ap({method: "increment_counts", threshold: threshold, record_sym: record_sym, record_value: @_gi_job_transaction[record_sym]})
+          if ((@_gi_job_transaction[record_sym] || 0) + (threshold || 1)) <= @_process_info[:counts][sym]
+            # thresholdが1000の場合は、1000件ごとにdbを更新する
+            # 更新するときは折角なので全部更新する
+            syms = @_process_info[:counts].keys
+            update_counts_by_process_info(syms)
+          end
+        end
+
+        def update_counts(**counts_hash)
+          # GiJob.logger.ap({method: "update_counts", counts_hash: counts_hash})
+          syms = []
+          counts_hash.each do |sym, value|
+            @_process_info[:counts][sym] = value
+            syms << sym
+          end
+          # GiJob.logger.ap({method: "update_counts", syms: syms})
+          update_counts_by_process_info(syms)
+        end
+
+        def update_counts_by_process_info(syms)
+          param = {}
+          syms.each do |sym|
+            value = @_process_info[:counts][sym]
+            record_sym = "counts_#{sym.to_s}".to_sym
+            param[record_sym] = value
+            # GiJob.logger.ap({method: "update_counts_by_process_info", sym: sym, record_sym: record_sym, value: value, param: param})
+          end
+          # GiJob.logger.ap({method: "update_counts_by_process_info", param: param})
+          @_gi_job_transaction.update!(param)
+        end
+
+        #
+        # def self.each_job_file_csv(job, headers: false)
+        #   job_file = job.job_files.present? ? job.job_files.first : nil
+        #   if job_file
+        #     data_source = job_file.data_source
+        #     # GiJob.logger.ap({data_source: data_source})
+        #
+        #     encoding = Getit::CsvUtils.create_encoding_param(data_source)
+        #     # GiJob.logger.ap({encoding: encoding})
+        #
+        #     csv = CSV.new(data_source, encoding: encoding, headers: headers)
+        #     row_num = 0
+        #     csv.each do |row|
+        #       row_num += 1
+        #       yield(row, row_num)
+        #     end
+        #   end
+        # end
+        #
+        # def increment_progress(job, need_update = true)
+        #   # 例外時に補足して件数情報をlogに出すために、インスタンスで処理件数を持つ
+        #   if @tmp_counts_progress.nil?
+        #     @tmp_counts_progress = job.counts_progress || 0
+        #   end
+        #   @tmp_counts_progress += 1
+        #   # file_upload時は、最後に件数更新を行うため、need_update = falseを想定
+        #   (job, @tmp_counts_progress) if need_update
+        # end
+        #
+        # def update_counts_progress(job, num)
+        #   job.update!({counts_progress: num || 0})
+        #   @tmp_counts_progress = num
+        # end
+        #
+        # def append_error_with(job, tag, message)
+        #   job.append_error(tag, message)
+        #   @has_error = true
+        # end
+        #
+        #
+        # def self.save_job_file!(job, additional_info)
+        #   # upload_fileがある場合はDBに格納する
+        #   if additional_info.has_key?(:uploaded_file)
+        #     # 一時ファイルパスを作成
+        #     tmp_file_path = self.create_file_path(job, additional_info[:uploaded_file].original_filename)
+        #
+        #     # 2回読み込むため、一時ファイルとして一旦保存する
+        #     file_copy(additional_info[:uploaded_file], tmp_file_path)
+        #
+        #     # レコードへのファイル保存
+        #     encoding = Getit::CsvUtils.create_encoding_param(File.new(tmp_file_path))
+        #     mode = "rt:#{encoding}"
+        #     # GiJob.logger.ap({mode: mode})
+        #     tmp_file = File.open(tmp_file_path, mode = mode).read
+        #     job_file = JobFile.new({
+        #       job: job,
+        #       file: tmp_file,
+        #       file_name: additional_info[:uploaded_file].original_filename,
+        #       counts_row: tmp_file.count("\n"),
+        #     })
+        #     job.update!({
+        #       job_files: [job_file],
+        #     })
+        #
+        #     # jobに対してActionDispatch::Fileみたいなのが渡せないため削除する
+        #     additional_info.delete(:uploaded_file)
+        #
+        #     # 古い一時ファイルを削除する
+        #     self.delete_old_files
+        #   end
+        # end
+        #
+        # def self.relation_master_schedule_job!(job, master_schedule_job)
+        #   if master_schedule_job.present? && job.respond_to?(:master_schedule_job)
+        #     # master_schedule_jobを紐づけ
+        #     job.master_schedule_job = master_schedule_job
+        #
+        #     if master_schedule_job.additional_info.present?
+        #       # master_schedule_jobに設定されているadditional_infoを引き継ぎ
+        #       master_schedule_job_additional_info = master_schedule_job.additional_info
+        #       if  master_schedule_job.additional_info[:next_one].present?
+        #         next_one = master_schedule_job.additional_info[:next_one].delete
+        #         master_schedule_job.save!
+        #         master_schedule_job_additional_info.merge!(next_one)
+        #       end
+        #       job.additional_info.merge!(master_schedule_job.additional_info)
+        #       job.save!
+        #     end
+        #
+        #     master_schedule_job.last_job = job
+        #     master_schedule_job.save!
+        #   end
+        #
+        #   job.save!
+        # end
+        #
+        # def self.create_file_path(job, file_name_suffix = ".csv")
+        #   file_name_prefix = "#{job.job_type}_" || ""
+        #   "#{self.tmp_dir}/job_file_#{file_name_prefix}#{job.id}#{file_name_suffix}"
+        # end
+        #
+        # def self.delete_old_files(time_limit = 14.days)
+        #   # 2週間前の一時ファイルを削除する
+        #   tmp_dir = self.tmp_dir
+        #   time_now = Time.now
+        #   threshold =  time_now - time_limit
+        #   GiJob.logger.ap("delete_old_file #{time_now} - #{time_limit} = threshold: #{threshold}")
+        #   deleted_paths = []
+        #   Dir.glob("#{tmp_dir}/job_file_*").select do |file_path|
+        #     File.mtime(file_path) < threshold
+        #   end.each do |file_path|
+        #     GiJob.logger.ap("delete_old_file: #{file_path}")
+        #     FileUtils.rm(file_path)
+        #     deleted_paths << file_path
+        #   end
+        #   deleted_paths
+        # end
+        #
+        # def self.tmp_dir
+        #   tmp_dir = "#{Dir.tmpdir}/job"
+        #   unless File.exist?(tmp_dir)
+        #     FileUtils.mkdir_p(tmp_dir)
+        #   end
+        #   tmp_dir
+        # end
+        #
+        # def self.file_copy(file, dst)
+        #   GiJob.logger.ap({file: file, dst: dst})
+        #   FileUtils.cp(file.path, dst)
+        #   # GiJob.logger.ap({rrr: file.read})
+        #   # File.open(dst, 'w') do |fp|
+        #   #   fp.write(file.read)
+        #   # end
+        # end
+        #
+        # def self.file_create(content, dst)
+        #   File.open(dst, 'w') do |fp|
+        #     fp.write(content)
+        #   end
+        # end
+        #
+        # #### slack通知系
+        # def notifier_slack(job:, time_start:, time_end: Time.zone.now, job_rc: {})
+        #   timestamp_hash = create_timestamp_hash(
+        #     time_start: time_start,
+        #     time_end: time_end,
+        #     counts_progress: job.counts_progress
+        #   )
+        #   attachments = []
+        #   attachments << create_slack_common_attachment(job, timestamp_hash)
+        #   slack_notifier_info = notifier_slack_imple(
+        #     attachments: attachments,
+        #     job: job,
+        #     timestamp_hash: timestamp_hash,
+        #     job_rc: job_rc
+        #   )
+        #
+        #   if slack_notifier_info.instance_of?(Array)
+        #     slack_notifier_info.each do |info|
+        #       slack_api_wrapper = SlackApiWrapper.new(info[:initialize_params] || {})
+        #       slack_api_wrapper.notifier(info[:notifier_params])
+        #     end
+        #   else
+        #     slack_api_wrapper = SlackApiWrapper.new
+        #     slack_api_wrapper.notifier(slack_notifier_info)
+        #   end
+        # end
+        #
+        # def create_slack_common_attachment(job, timestamp_hash)
+        #   job_info_string = "#{job.shop.shopify_domain} (#{job.shop.id}) #{job.enum_localize(:job_type)} (#{job.id})"
+        #   GiJob.logger.info("[JOB-INFO] #{job_info_string} End #{timestamp_hash[:time_description]} #{timestamp_hash[:processing_count_per_second]}")
+        #
+        #   main_color = job.error? ? "danger" : "good"
+        #   text_string = "処理件数: #{job.counts_progress} / #{job.counts_all}"
+        #   text_string += "\n#{timestamp_hash[:timestamp_text]}"
+        #
+        #   if job.process_status_suspended?
+        #     text_string += "\n一時停止: #{job.process_progress} 件目"
+        #   elsif job.process_status_terminated?
+        #     text_string += "\n途中終了: #{job.process_progress} 件目"
+        #   end
+        #
+        #   job_logs_hash = job.create_job_logs_hash
+        #   if 0 < job_logs_hash[:error].size
+        #     main_color = "warning"
+        #     text_string += "\nエラー件数: #{job_logs_hash[:error].size}"
+        #     text_string += "\n先頭エラーメッセージ: #{job_logs_hash[:error].first.description}"
+        #   end
+        #
+        #   attachment = {
+        #     title: "#{job_info_string}",
+        #     color: main_color,
+        #     text: "#{text_string}",
+        #   }
+        #   attachment
+        # end
+        #
+        # def notifier_slack_imple(
+        #   attachments: [],
+        #   job:,
+        #   timestamp_hash: {},
+        #   job_rc: {}
+        # )
+        #   # 必要であれば派生クラスで拡張
+        #   create_simple_slack_notifer(
+        #     attachments: attachments,
+        #     job: job,
+        #     timestamp_hash: timestamp_hash,
+        #     job_rc: job_rc
+        #   )
+        # end
+        #
+        # def create_timestamp_hash(time_start:, time_end: Time.zone.now, counts_progress: nil)
+        #   time_format = '%Y/%m/%d %H:%M:%S'
+        #   time_elapsed = (time_end - time_start).round(2) # 経過時間
+        #   time_description = "#{time_start.strftime(time_format)} ~ #{time_end.strftime(time_format)} (#{time_elapsed}秒)" # 開始終了（経過時間）
+        #   processing_count_per_second = "#{(counts_progress && 0 < counts_progress) ? (counts_progress / time_elapsed).round(2) : "-"} 件/秒"  # 処理件数（秒間処理件数）
+        #   timestamp_text = "実行時間: #{time_description}\n処理速度: #{processing_count_per_second}"
+        #
+        #   {
+        #     time_start: time_start,
+        #     time_end: time_end,
+        #     time_elapsed: time_elapsed,
+        #     counts_progress: counts_progress,
+        #     time_description: time_description,
+        #     processing_count_per_second: processing_count_per_second,
+        #     timestamp_text: timestamp_text,
+        #   }
+        # end
+        #
+        # def create_simple_slack_notifer(
+        #   attachments: [],
+        #   job:,
+        #   timestamp_hash: {},
+        #   job_rc: {}
+        # )
+        #   counts_hash = job_rc.is_a?(Hash) ? job_rc[:counts_hash] : {}
+        #   GiJob.logger.ap({counts_hash: counts_hash})
+        #   text = "#{job.to_simple[:local][:job_type]} - #{timestamp_hash[:time_start].strftime('%-m月%-d日 %-H:%M')}"
+        #
+        #   job_counts_text = nil
+        #   color = nil
+        #   if counts_hash.present?
+        #     job_counts_text = "処理件数: #{counts_hash[:counts]}件"
+        #     color = "good"
+        #   else
+        #     job_counts_text = "ジョブ結果が正常に取得できませんでした"
+        #     color = "warning"
+        #   end
+        #
+        #   info_links = job.job_log_files.map {|job_log_file| job_log_file.slack_link}
+        #
+        #   tmp_attachments = [{
+        #     title: "処理詳細",
+        #     color: color,
+        #     text: "#{job_counts_text}",
+        #   }, {
+        #     title: "ログファイル",
+        #     color: "good",
+        #     text: "#{info_links.join("\n")}",
+        #   }]
+        #
+        #   if counts_hash.present? && counts_hash[:errors].present?
+        #     tmp_attachments << {
+        #       title: "エラー",
+        #       color: "danger",
+        #       text: "#{counts_hash[:errors].join("\n")}",
+        #     }
+        #   end
+        #
+        #   attachments |= tmp_attachments
+        #   {text: text, attachments: attachments}
+        # end
+        #
+
+        ##################### シグナル捕捉 & suspended
+        def set_signal_trap
+          @_is_signal_trapped = false
+          Signal.trap('TERM') do
+            # シグナル発生
+            GiJob.logger.info('trap TERM!')
+            @_is_signal_trapped = true
+          end
+
+          Signal.trap('TSTP') do
+            # シグナル発生
+            GiJob.logger.info('trap TSTP!')
+            @_is_signal_trapped = true
+          end
+        end
+
+        def process_status_transaction(
+          gi_job_transaction: @_gi_job_transaction,
+          suspendable: true
+        )
+          # suspendable = true の場合、suspended する
+          # suspendable = false の場合、terminated する
+          begin
+            yield
+
+          rescue JobCommandSuspended => e
+            # GiJob.logger.ap({rescue: e})
+            message = e.message
+
+            info_string =  "#{message} のため #{@_process_info[:counts][:progress]} 件目の処理中に中断しました"
+            process_status = :terminated
+
+            if suspendable
+              info_string =  "#{message} のため #{@_process_info[:counts][:progress]} 件目の処理中に一時停止しました"
+              process_status = :suspended
+            end
+
+            gi_job_transaction.append_log_info(division: "job停止", description: "#{info_string}")
+            gi_job_transaction.update!({
+              process_status: process_status,
+              process_progress: e.process_progress
+            })
+          end
+        end
+
+        def check_job_command!
+          if @_is_signal_trapped
+            # ジョブ停止要求あり
+            raise JobCommandSuspended.new(@_process_progress || nil), "サーバー停止要求"
+          end
+        end
+
+        def with_job_command(process_progress_key: nil)
+          if process_progress_key.present?
+            @_process_progress = {key: process_progress_key}
+          end
+          check_job_command!
+
+          # skip判断
+          if @_gi_job_transaction.process_progress.present? && @_process_progress.present?
+            # 途中まで処理されている場合は、そこまで skip する
+            suspended_key = @_gi_job_transaction.process_progress.try(:key, nil)
+            now_key = @_process_progress.try(:key, nil)
+
+            if process_progress_key == suspended_key
+              # 途中まで処理されていたkeyと一致した場合は再開
+              # process_progress を削除しておく
+              @_gi_job_transaction.update!(process_progress: nil)
+
+            else
+              # 処理済みのため skip
+              GiJob.logger.ap("実施済みの為スキップします process_progress_key: #{process_progress_key} != suspended_key: #{suspended_progress_key}")
+              return nil
+            end
+          end
+
+          yield
+
+        end
+
+        def sleep_as_check_job_command(seconds, &block)
+
+          sleep_seconds = seconds
+          sleep_loop_max_counts = 1
+          if 1 < seconds
+            sleep_seconds = 1
+            sleep_loop_max_counts = seconds.ceil
+          end
+
+          sleep_loop_max_counts.times do |index|
+            GiJob.logger.ap({method: "sleep_as_check_job_command", loops: "#{index}/#{sleep_loop_max_counts}"})
+
+            # チェックしながら小分けにして休む
+            check_job_command!
+            sleep(sleep_seconds)
+
+            if block_given?
+              # ブロックが渡されている場合は評価して、必要に応じて抜ける
+              rc = yield
+              break if rc.present?
+            end
+          end
+
+        end
+
+
+      end # end JobRunner
+    end
+  end
+end