eco-rake 0.1.1

data/lib/eco-rake/lib/export/payload.rb

@@ -0,0 +1,78 @@
+# Use case for special integrations. It requires some use cases to be present
+#  1. `-export-select-options`
+#  2. `-export-registers`
+#  3. `-export-pack`
+#  4. `-export-sftp-push`
+require 'optparse/time'
+class EcoRake
+  module Lib
+    module Export
+      class Payload < EcoRake::Lib::BaseTask
+        INCLUDED_OPTIONS = %i[csv simulate].freeze
+        FORWARD_RULES    = {
+          enviro:   ->(enviro) { "-#{enviro}" },
+          simulate: '-simulate',
+          csv:      '-csv',
+          full:     ->(full) { full ? nil : '-delta' },
+          asat:     ->(asat) { "-asatdate #{asat}" }
+        }.freeze
+
+        options_with_defaults true
+        option '-s', '--simulate', TrueClass, 'Do a dry-run (with no changes)'
+        option '-e', '--enviro ENVIRO', String, desc: 'Target environment to run against (i.e. org, live)', required: true # , default_lookup: :default_enviro
+        option '-f', '--[no-]full', TrueClass, default: false, desc: 'If the PAYLOAD file is a full file (false: means delta)'
+        option '-c', '--csv', TrueClass, default: true, desc: 'Generate files in csv format?'
+        option '-a', '--asat [DATE]', Time, default: Time.now.iso8601, desc: 'Specifies the date when the export was done (default: now).' do |value|
+          value&.iso8601
+        end
+
+        option_forwarding(**FORWARD_RULES)
+
+        def task(*_args)
+          sh_chain(commands) do |ok, _res|
+            exit 1 unless ok
+          end
+        end
+
+        private
+
+        def commands
+          cmds  = []
+          cmds << export_select_options
+          cmds << export_registers
+          cmds << export_pack
+          cmds << export_sftp_push unless options[:simulate]
+          cmds
+        end
+
+        def export_select_options
+          forward_command('-export-select-options')
+        end
+
+        def export_registers
+          forward_command('-export-registers')
+        end
+
+        def export_pack
+          forward_command('-export-pack', :full, :asat)
+        end
+
+        def export_sftp_push
+          base_command('-export-sftp-push')
+        end
+
+        def forward_command(use, *opts)
+          raise "Expecting String with usecase. Given: #{use.class}" unless use.is_a?(String)
+          cmd = [base_command(use)]
+          cmd.push(*forward_options(*self.class::INCLUDED_OPTIONS, *opts))
+          cmd = yield(cmd) if block_given?
+          string_cmd(*cmd)
+        end
+
+        def base_command(use = nil)
+          string_cmd(ruby_runner, forward_option(:enviro), use)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/export.rb

@@ -0,0 +1,8 @@
+require_relative 'export/payload'
+
+class EcoRake
+  module Lib
+    module Export
+    end
+  end
+end

data/lib/eco-rake/lib/files/decrypt.rb

@@ -0,0 +1,48 @@
+class EcoRake
+  module Lib
+    module Files
+      class Decrypt < EcoRake::Lib::BaseTask
+        options_with_defaults true
+
+        option '-s', '--simulate', TrueClass, 'Do a dry-run (with no changes)'
+        option '-l', '--list', TrueClass, desc: 'Lists available gpg feed files'
+        option '-d', '--folder NAME', default: '.', desc: 'Source local folder'
+        attr_const :ignore_mdc_error, default: false
+
+        def task(*_args)
+          return display_target_files if options[:list]
+          return warn_missing_file    if target_files.empty?
+          target_files.each do |file|
+            delete_file(gpg_to_csv_filename(file))
+            sh decrypt_command(file, ignore_mdc_error: ignore_mdc_error)
+          end
+          delete_file(*target_files, message: "Deleting files from '#{source_folder}'") unless options[:simulate]
+        end
+
+        def display_target_files
+          puts "Source gpg files ('#{source_folder}'):"
+          target_files.each {|file| puts "  • #{File.basename(file)}"}
+        end
+
+        def warn_missing_file
+          puts "Could not find any file in folder '#{source_folder}'"
+        end
+
+        private
+
+        # Amont the `target_files` the last in alphabetic order.
+        def latest_file
+          @latest_file ||= target_files.last
+        end
+
+        def target_files
+          @target_files ||= gpg_files(source_folder)
+        end
+
+        def source_folder
+          @source_folder ||= File.expand_path(options[:folder])
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/files/purge.rb

@@ -0,0 +1,73 @@
+class EcoRake
+  module Lib
+    module Files
+      class Purge < EcoRake::Lib::BaseTask
+        options_with_defaults true
+
+        option '-e', '--enviro ENVIRO', String, desc: 'Target environment to run against (i.e. org, live)', required: true
+        option '-d', '--folder NAME', desc: 'Source local folder'
+        option '-l', '--list', TrueClass, desc: 'Lists files that will be deleted'
+        option '-o', '--older-than [DAYS]', Integer, desc: 'Number of days files to archive should be older than'
+        option '-r', '--remove', TrueClass, desc: "It deletes those files"
+
+        def task(*_args)
+          if target_files.empty?
+            puts "There were no files in folder '#{source_folder}' to be #{str_op}"
+          elsif options[:list]
+            msg  = "#{target_files.count} target log files (from '#{source_folder}') will be #{str_op}"
+            msg << " to '#{dest_folder}':" unless remove?
+            puts msg
+            target_files.each {|file| puts "  • #{File.basename(file)}"}
+          elsif options[:remove]
+            delete_file(*target_files, message: "Removing the following #{target_files.count} files from '#{source_folder}':")
+          else
+            ensure_dest_folder!
+            msg = "Moving #{target_files.count} log files from '#{source_folder}' to the '#{dest_folder}' folder:"
+            move_file(*target_files, folder: dest_folder, message: msg)
+          end
+        end
+
+        private
+
+        # Based on `older-than` option
+        # @return [Array<String>]
+        def target_files
+          @target_files ||= folder_files(source_folder, older_than: older_than)
+        end
+
+        # Folder where the files will be moved (when applicable)
+        def dest_folder
+          @dest_folder ||= File.join(source_folder, 'archive').tap do |folder|
+            directory folder
+          end
+        end
+
+        #  It declares the folder as a task and creates it if it doesn't exist
+        def ensure_dest_folder!
+          directory dest_folder
+          Rake::Task[dest_folder].invoke
+        end
+
+        # @return [String]
+        def source_folder
+          @source_folder ||= File.expand_path(options[:folder])
+        end
+
+        # @return [Integer] number of days the files are older than.
+        def older_than
+          options[:older_than] || (remove?? 15 : 3)
+        end
+
+        # @return [String]
+        def str_op
+          remove?? 'deleted' : 'moved'
+        end
+
+        # @return [Boolean] whether the files should be moved or removed/deleted.
+        def remove?
+          options[:remove]
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/files/sftp.rb

@@ -0,0 +1,49 @@
+class EcoRake
+  module Lib
+    module Files
+      class Sftp < EcoRake::Lib::BaseTask
+        FORWARD_RULES = {
+          enviro:   ->(enviro) { "-#{enviro}" },
+          folder:   ->(folder) { "-local-folder #{folder}"},
+          list:     '-list',
+          get_last: '-get-last',
+          get:      '-get',
+          archive:  '-archive'
+        }.freeze
+
+        options_with_defaults true
+
+        option '-e', '--enviro ENVIRO', String, desc: 'Target environment to run against (i.e. org, live)', required: true
+        option '-d', '--folder NAME', default: '.', desc: 'Source local folder'
+        option '-l', '--list', TrueClass, desc: 'Lists available CSV feed files'
+        option '-g', '--get', TrueClass, desc: 'Gets all available CSV feed files'
+        option '-t', '--get-last', TrueClass, desc: 'Gets the last available CSV feed file'
+        option '-a', '--archive', TrueClass, desc: "Moves the remote CSV feed files to the '/Archive' folder"
+
+        option_forwarding(**FORWARD_RULES)
+
+        # attr_const :target_enviro, required: true
+        # option_reopen :enviro, default_lookup: :target_enviro
+
+        def task(*_args)
+          sh sftp_command
+        end
+
+        private
+
+        def sftp_command
+          cmd  = [base_command]
+          cmd << forward_option(:folder)
+          cmd << forward_options(:list, :get_last, :get, :archive).compact.first || '-list'
+          cmd << '-no-people'
+          cmd = yield(cmd) if block_given?
+          string_cmd(*cmd)
+        end
+
+        def base_command
+          string_cmd(ruby_runner, forward_option(:enviro), '-sftp')
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/files.rb

@@ -0,0 +1,10 @@
+require_relative 'files/purge'
+require_relative 'files/decrypt'
+require_relative 'files/sftp'
+
+class EcoRake
+  module Lib
+    module Files
+    end
+  end
+end

data/lib/eco-rake/lib/notify/mailer.rb

@@ -0,0 +1,24 @@
+class EcoRake
+  module Lib
+    module Notify
+      class Mailer < EcoRake::Lib::BaseTask
+        option '-t', '--to EMAIL', String, 'Destination recipient', required: true
+        option '-s', '--subject SUBJECT', String, 'Subject of the email', required: true
+        option '-m', '--body MESSAGE', String, 'The message of the email', required: true
+        option '-c', '--cc EMAIL', String, 'CCing someone else'
+        option '-b', '--bcc EMAIL', String, 'BCCing someone else'
+
+        def task(*_args)
+          kargs = {
+            to:      options[:to],
+            subject: options[:subject],
+            body:    options[:body]
+          }
+          kargs.merge!(cc: options[:cc])   if options[:cc]
+          kargs.merge!(bcc: options[:bcc]) if options[:bcc]
+          mailer.mail(**kargs)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/notify.rb

@@ -0,0 +1,8 @@
+require_relative 'notify/mailer'
+
+class EcoRake
+  module Lib
+    module Notify
+    end
+  end
+end

data/lib/eco-rake/lib/options.rb

@@ -0,0 +1,8 @@
+require_relative 'options/usecase'
+
+class EcoRake
+  module Sample
+    module Options
+    end
+  end
+end

data/lib/eco-rake/lib/people/base_task.rb

@@ -0,0 +1,16 @@
+class EcoRake
+  module Lib
+    module People
+      class BaseTask < EcoRake::Lib::BaseTask
+        FORWARD_RULES = {
+          enviro: ->(enviro) { "-#{enviro}" }
+        }.freeze
+
+        options_with_defaults true
+        options_use EcoRake::Lib::People::SyncOptions
+
+        option_forwarding(**FORWARD_RULES)
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/people/sync_launch.rb

@@ -0,0 +1,131 @@
+class EcoRake
+  module Lib
+    module People
+      # @todo on_error_email to ensure always notified
+      # @todo ping some back-end that it was run
+      #   - Should be able to log at debug level.
+      class SyncLaunch < EcoRake::Lib::People::BaseTask
+        ADDITIONAL_OPTIONS = %i[only_stats no_policy simulate].freeze
+        FORWARD_RULES = {
+          schema:     ->(schema) { "-schema-id \"#{schema}\"" },
+          only_stats: '-feed-only-stats',
+          no_policy:  '-skip-batch-policy',
+          simulate:   '-simulate'
+        }.freeze
+
+        attr_const :target_enviro, required: true
+        option_reopen :enviro, default_lookup: :target_enviro
+
+        attr_const :base_usecase, :default_schema, :file_pattern, required: true
+        attr_const :snapshot_mode, default: :full
+        attr_const :local_folder, default: '.'
+        attr_const :mail_to
+
+        option_reopen :schema, default_lookup: :default_schema, required: true
+        option_reopen :folder, default_lookup: :local_folder
+
+        option_forwarding(**FORWARD_RULES)
+
+        def task(*_args)
+          return missing_files_notify unless latest_file
+          return process_deltas       if delta?
+          return process_full_file    if full?
+        end
+
+        private
+
+        def process_full_file
+          sh people_get_command unless options[:no_get]
+          sh_continue sync_command(latest_file)
+          clear_files unless options[:simulate]
+        end
+
+        def process_deltas
+          target_files.each do |file|
+            sh sync_command(file)
+            next if options[:simulate]
+            puts "Deleting file #{file}"
+            File.delete(file)
+          end
+        end
+
+        def missing_files_notify
+          puts "Missing files to be processed"
+          exit 1 if options[:simulate]
+          exit 1 unless inbox = mail_to
+          email_missing_files(enviro: target_enviro, to: inbox)
+          exit 1
+        end
+
+        # @yield [cmd] do something to extend the command
+        # @yieldparam cmd [Array<String>] the command as this task would generate it.
+        # @yieldresult [Array<String>] the final command
+        # @return [String] the sync command
+        def sync_command(file)
+          cmd = []
+          cmd << ruby_runner
+          cmd << forward_option(:enviro)
+          cmd << forward_option(:schema)
+          cmd << '-get-partial' if delta?
+          cmd << base_command(file)
+          cmd.concat(forward_options(*self.class::ADDITIONAL_OPTIONS))
+          cmd = yield(cmd) if block_given?
+          string_cmd(*cmd)
+        end
+
+        # Generate command string to get people
+        def people_get_command
+          string_cmd(ruby_runner, forward_option(:enviro), '-get-people')
+        end
+
+        # Base command scoping.
+        # @note it ensures basic information is not missing or inconsistent.
+        def base_command(file_or_folder)
+          raise "Missing target file or folder in #{self.class}" if file_or_folder.to_s.strip.empty?
+          usecase = base_usecase.to_sym
+          case usecase
+          when :hris
+            msg  = "Inconsistent configuration in #{self.class}. BASE_USECASE is '#{usecase}', "
+            msg << "but file SNAPSHOT_MODE is '#{snapshot_mode}'"
+            raise msg if delta?
+            "-hris-from #{double_quote(file_or_folder)}"
+          when :upsert
+            "-upsert-from #{double_quote(file_or_folder)}"
+          else
+            raise ArgumentError, "Unknown use case '#{usecase}'"
+          end
+        end
+
+        def full?
+          snapshot_mode.to_s.downcase.to_sym == :full
+        end
+
+        def delta?
+          mode = snapshot_mode.to_s.downcase.to_sym
+          %i[partial delta].any? {|m| m == mode}
+        end
+
+        # Amont the `target_files` the last in alphabetic order.
+        def latest_file
+          @latest_file ||= target_files.last
+        end
+
+        # @note if there is a file_pattern method or FILE_PATTERN const, it's used as a pattern.
+        # @return [Array<String>] the `csv` files of the target folder
+        def target_files
+          @target_files ||= csv_files(options[:folder], regexp: file_pattern)
+        end
+
+        # Deletes the files identified as target.
+        def clear_files
+          deleted_files = target_files.each_with_object([]) do |file, deleted|
+            next unless File.exist?(file)
+            File.delete(file)
+            deleted << file
+          end
+          puts "Deleted these files:\n  • #{deleted_files.join("\n  • ")}" unless deleted_files.empty?
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/people/sync_options.rb

@@ -0,0 +1,15 @@
+class EcoRake
+  module Lib
+    module People
+      class SyncOptions < EcoRake::Options::Set
+        option '-s', '--simulate', TrueClass, 'Do a dry-run (with no changes)'
+        option '-e', '--enviro ENVIRO', String, desc: 'Target environment to run against (i.e. org, live)', required: true
+        option '-c', '--schema NAME', "Target person schema."
+        option '-d', '--folder NAME', desc: 'Source local folder'
+        option '-o', '--only-stats', TrueClass, desc: 'To display only stats in the feedback'
+        option '-b', '--no-policy', FalseClass, desc: 'To skip the batch policy'
+        option '-n', '--no-get', FalseClass, desc: 'Skip get people step'
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/people/sync_process.rb

@@ -0,0 +1,48 @@
+class EcoRake
+  module Lib
+    module People
+      # The top level task that organizes all the people sync
+      class SyncProcess < EcoRake::Lib::People::SyncRely
+        attr_const :do_decrypt, default: false
+        attr_const :target_task
+
+        attr_const :target_enviro, required: true
+        option_reopen :enviro, default_lookup: :target_enviro
+
+        attr_const :local_folder, default: '.'
+        attr_const :mail_to
+
+        option_reopen :folder, default_lookup: :local_folder
+
+        def task(*_args)
+          upsert_local_dir(options[:folder])
+          sh_continue rake_sftp_get
+          sh rake_decrypt if do_decrypt
+          sh_continue rake_sync_command
+          return if options[:simulate]
+          sh_continue rake_sftp_archive
+          sh_continue rake_files_purge('cache')
+          sh_continue rake_files_purge('requests')
+        end
+
+        private
+
+        def rake_sftp_get
+          rake_command('csv:sftp', *forward_options(:enviro, :folder), '-t')
+        end
+
+        def rake_sftp_archive
+          rake_command('csv:sftp', *forward_options(:enviro, :folder), '-a')
+        end
+
+        def rake_decrypt
+          array_cmd('rake csv:decrypt', '--', forward_option(:folder)).join(" ")
+        end
+
+        def rake_files_purge(folder, operation: '--remove')
+          rake_command('logs:purge', *forward_options(:enviro), "-d #{folder}", operation)
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/people/sync_rely.rb

@@ -0,0 +1,47 @@
+class EcoRake
+  module Lib
+    module People
+      # The top level task that organizes all the people sync
+      class SyncRely < EcoRake::Lib::People::BaseTask
+        FORWARD_RULES = {
+          enviro:     :mirror,
+          schema:     :mirror,
+          folder:     :mirror,
+          only_stats: :mirror,
+          no_policy:  :mirror,
+          no_get:     :mirror,
+          simulate:   :mirror
+        }.freeze
+
+        option_forwarding(**FORWARD_RULES)
+
+        attr_const :target_task
+
+        def task(*_args)
+          sh_continue rake_sync_command
+        end
+
+        private
+
+        def rake_sync_command
+          rake_command(namespaced_task, *forward_options(*FORWARD_RULES.keys - [:enviro]))
+        end
+
+        def rake_command(task_name, *options)
+          string_cmd(base_command(task_name), '--', *options)
+        end
+
+        def base_command(task_name = namespaced_task)
+          string_cmd('rake', task_name)
+        end
+
+        def namespaced_task(task_name = target_task)
+          ns             = self.class.namespace || ''
+          ns_with_enviro = ns.split(':').any? {|s| s == options[:enviro]}
+          ns = ns_with_enviro ? ns : "#{ns}:#{options[:enviro]}"
+          "#{ns}:#{task_name || self.class.task}"
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/people.rb

@@ -0,0 +1,12 @@
+require_relative 'people/sync_options'
+require_relative 'people/base_task'
+require_relative 'people/sync_rely'
+require_relative 'people/sync_process'
+require_relative 'people/sync_launch'
+
+class EcoRake
+  module Lib
+    module People
+    end
+  end
+end

data/lib/eco-rake/lib/task/runner_launch.rb

@@ -0,0 +1,34 @@
+class EcoRake
+  module Lib
+    module Task
+      class RunnerLaunch < EcoRake::Lib::BaseTask
+        FORWARD_RULES = {
+          enviro:   ->(enviro) { "-#{enviro}"},
+          simulate: '-simulate'
+        }.freeze
+
+        options_with_defaults true
+        options_use EcoRake::Lib::Task::RunnerOptions
+
+        attr_const :target_enviro, required: true
+        option_reopen :enviro, default_lookup: :target_enviro
+
+        option_forwarding(**FORWARD_RULES)
+
+        private
+
+        def command(*args)
+          cmd = [ruby_runner]
+          cmd.push(*forward_options(:enviro, :simulate))
+          cmd.push(*args)
+          cmd = yield(cmd) if block_given?
+          string_cmd(*cmd)
+        end
+
+        def people_get_command
+          string_cmd(ruby_runner, forward_option(:enviro), '-get-people')
+        end
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/task/runner_options.rb

@@ -0,0 +1,11 @@
+class EcoRake
+  module Lib
+    module Task
+      class RunnerOptions < EcoRake::Options::Set
+        option '-s', '--simulate', TrueClass, 'Do a dry-run (with no changes)'
+        option '-e', '--enviro ENVIRO', String, desc: 'Target environment to run against (i.e. org, live)', required: true
+        option '-t', '--task NAME', String, desc: 'Target task to run', required: true
+      end
+    end
+  end
+end

data/lib/eco-rake/lib/task/runner_rely.rb

@@ -0,0 +1,40 @@
+class EcoRake
+  module Lib
+    module Task
+      class RunnerRely < EcoRake::Lib::BaseTask
+        FORWARD_RULES = {
+          simulate: :mirror,
+          task:     :mirror
+        }.freeze
+
+        options_with_defaults true
+        options_use EcoRake::Lib::Task::RunnerOptions
+
+        option_forwarding(**FORWARD_RULES)
+
+        def task(*_args)
+          sh_continue command
+        end
+
+        private
+
+        def command
+          cmd  = [base_command]
+          cmd << target_task
+          cmd << '--'
+          cmd << forward_option(:task)
+          cmd << forward_option(:simulate)
+          string_cmd(*cmd)
+        end
+
+        def base_command
+          "rake"
+        end
+
+        def target_task
+          raise "In a hub you should re-write this method"
+        end
+      end
+    end
+  end
+end