pdi 2.0.0.pre.alpha

data/lib/pdi/executor/result.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'status'
+
+module Pdi
+  class Executor
+    # General return object for an execution call result.
+    class Result
+      extend Forwardable
+      acts_as_hashable
+
+      attr_reader :args, :status
+
+      def_delegators :status, :code, :out, :pid
+
+      def initialize(args:, status: {})
+        @args   = args
+        @status = Status.make(status)
+
+        freeze
+      end
+    end
+  end
+end

data/lib/pdi/executor/status.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Pdi
+  class Executor
+    # General return object for describing the operating system return data.
+    class Status
+      acts_as_hashable
+
+      attr_reader :code, :out, :pid
+
+      def initialize(code:, out: '', pid:)
+        @code = code
+        @out  = out
+        @pid  = pid
+
+        freeze
+      end
+    end
+  end
+end

data/lib/pdi/spoon.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'spoon/kitchen_error'
+require_relative 'spoon/options'
+require_relative 'spoon/pan_error'
+require_relative 'spoon/parser'
+require_relative 'spoon/result'
+
+module Pdi
+  # This class is the main wrapper for PDI's pan and kitchen scripts.
+  class Spoon
+    DEFAULT_KITCHEN = 'kitchen.sh'
+    DEFAULT_PAN     = 'pan.sh'
+
+    TYPES_TO_ERRORS = {
+      Options::Type::JOB => KitchenError,
+      Options::Type::TRANSFORMATION => PanError
+    }.freeze
+
+    attr_reader :args, :dir, :kitchen, :pan
+
+    def initialize(
+      args: [],
+      dir:,
+      kitchen: DEFAULT_KITCHEN,
+      pan: DEFAULT_PAN,
+      timeout_in_seconds: nil
+    )
+      assert_required(:dir, dir)
+      assert_required(:kitchen, kitchen)
+      assert_required(:pan, pan)
+
+      @args           = Array(args)
+      @dir            = File.expand_path(dir.to_s)
+      @kitchen        = kitchen.to_s
+      @pan            = pan.to_s
+      @executor       = Executor.new(timeout_in_seconds: timeout_in_seconds)
+      @parser         = Parser.new
+
+      freeze
+    end
+
+    # Returns a Spoon::Result instance when PDI returns error code 0 or else raises
+    # a KitchenError since Kitchen was used to run the version command.
+    def version
+      final_args = [kitchen_path] + args + [Options::Arg.new(Options::Arg::Key::VERSION)]
+
+      result       = executor.run(final_args)
+      version_line = parser.version(result.out)
+
+      raise(KitchenError, result) if result.code != 0
+
+      Result.new(result, version_line)
+    end
+
+    # Returns an Executor::Result instance when PDI returns error code 0 or else raises
+    # a PanError (transformation) or KitchenError (job).
+    def run(options)
+      options  = Options.make(options)
+      all_args = run_args(options)
+
+      executor.run(all_args).tap do |result|
+        raise(error_constant(options), result) if result.code != 0
+      end
+    end
+
+    private
+
+    attr_reader :executor, :parser
+
+    def error_constant(options)
+      TYPES_TO_ERRORS.fetch(options.type)
+    end
+
+    def run_args(options)
+      [script_path(options.type)] + args + options.to_args
+    end
+
+    def script_path(options_type)
+      if options_type == Options::Type::JOB
+        kitchen_path
+      elsif options_type == Options::Type::TRANSFORMATION
+        pan_path
+      end
+    end
+
+    def kitchen_path
+      File.join(dir, kitchen)
+    end
+
+    def pan_path
+      File.join(dir, pan)
+    end
+
+    def assert_required(name, value)
+      raise ArgumentError, "#{name} is required" if value.to_s.empty?
+    end
+  end
+end

data/lib/pdi/spoon/kitchen_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Pdi
+  class Spoon
+    # This class subclasses Ruby's StandardError and provides a mapping to custom Kitchen
+    # specific error codes to messages.
+    # You can find the list of errors in Pentaho's documentation site, for example:
+    # https://help.pentaho.com/Documentation/8.0/Products/Data_Integration/Command_Line_Tools
+    class KitchenError < StandardError
+      MESSAGES = {
+        '1' => 'Errors occurred during processing',
+        '2' => 'An unexpected error occurred during loading or running of the job',
+        '7' => "The job couldn't be loaded from XML or the Repository",
+        '8' => 'Error loading steps or plugins (error in loading one of the plugins mostly)',
+        '9' => 'Command line usage printing'
+      }.freeze
+
+      attr_reader :execution
+
+      def initialize(execution)
+        @execution = execution
+
+        message = MESSAGES[execution.code.to_s] || 'Unknown'
+
+        super(message)
+      end
+    end
+  end
+end

data/lib/pdi/spoon/options.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'options/level'
+require_relative 'options/param'
+
+module Pdi
+  class Spoon
+    # This class serves as the input for executing a transformation or job through Pan or Kitchen.
+    class Options
+      acts_as_hashable
+
+      module Type
+        JOB            = :job
+        TRANSFORMATION = :transformation
+      end
+
+      TYPES_TO_KEYS = {
+        Type::JOB => Arg::Key::JOB,
+        Type::TRANSFORMATION => Arg::Key::TRANS
+      }.freeze
+
+      attr_reader :level,
+                  :name,
+                  :params,
+                  :repository,
+                  :type
+
+      def initialize(
+        level: Level::BASIC,
+        name:,
+        params: {},
+        repository:,
+        type:
+      )
+        raise ArgumentError, 'name is required'       if name.to_s.empty?
+        raise ArgumentError, 'repository is required' if repository.to_s.empty?
+        raise ArgumentError, 'type is required'       if type.to_s.empty?
+
+        @level      = constant(Level, level)
+        @name       = name.to_s
+        @params     = params || {}
+        @repository = repository.to_s
+        @type       = constant(Type, type)
+
+        freeze
+      end
+
+      def to_args
+        base_args + param_args
+      end
+
+      private
+
+      def key
+        TYPES_TO_KEYS.fetch(type)
+      end
+
+      def base_args
+        [
+          Arg.new(Arg::Key::REP, repository),
+          Arg.new(key, name),
+          Arg.new(Arg::Key::LEVEL, level)
+        ]
+      end
+
+      def param_args
+        params.map { |key, value| Param.new(key, value) }
+      end
+
+      def constant(constant, value)
+        constant.const_get(value.to_s.upcase.to_sym)
+      end
+    end
+  end
+end

data/lib/pdi/spoon/options/arg.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Pdi
+  class Spoon
+    class Options
+      # This class can form Pentaho-specific command-line arguments.
+      class Arg
+        COLON         = ':'
+        DOUBLE_QUOTE  = '"'
+        EMPTY         = ''
+        HYPHEN        = '-'
+        SPACE         = ' '
+
+        module Key
+          JOB     = :job
+          LEVEL   = :level
+          PARAM   = :param
+          REP     = :rep
+          TRANS   = :trans
+          VERSION = :version
+        end
+
+        attr_reader :key, :value
+
+        def initialize(key, value = '')
+          raise ArgumentError, 'key is required' if key.to_s.empty?
+
+          @key   = Key.const_get(key.to_s.upcase.to_sym)
+          @value = value.to_s
+
+          freeze
+        end
+
+        def to_s
+          separator = value.to_s.empty? ? EMPTY : COLON
+          wrapper   = wrap?(key, value) ? DOUBLE_QUOTE : EMPTY
+          prefix    = HYPHEN
+
+          "#{wrapper}#{prefix}#{key}#{separator}#{value}#{wrapper}"
+        end
+
+        def hash
+          [key, value].hash
+        end
+
+        def ==(other)
+          other.instance_of?(self.class) &&
+            key == other.key &&
+            value == other.value
+        end
+        alias eql? ==
+
+        private
+
+        def wrap?(key, value)
+          key.to_s.include?(SPACE) || value.to_s.include?(SPACE)
+        end
+      end
+    end
+  end
+end

data/lib/pdi/spoon/options/level.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Pdi
+  class Spoon
+    class Options
+      module Level
+        BASIC     = 'Basic'
+        DETAILED  = 'Detailed'
+        DEBUG     = 'Debug'
+        ERROR     = 'Error'
+        NOTHING   = 'Nothing'
+        ROW_LEVEL = 'Rowlevel'
+      end
+    end
+  end
+end

data/lib/pdi/spoon/options/param.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'arg'
+
+module Pdi
+  class Spoon
+    class Options
+      # This class sub-classes Arg and knows how to form param key-value pair arguments.
+      class Param < Arg
+        EQUALS = '='
+
+        attr_reader :key, :value
+
+        def initialize(key, value = '')
+          super(Key::PARAM, "#{key}#{EQUALS}#{value}")
+
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/pdi/spoon/pan_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Pdi
+  class Spoon
+    # This class subclasses Ruby's StandardError and provides a mapping to custom Pan
+    # specific error codes to messages.
+    # You can find the list of errors in Pentaho's documentation site, for example:
+    # https://help.pentaho.com/Documentation/8.0/Products/Data_Integration/Command_Line_Tools
+    class PanError < StandardError
+      MESSAGES = {
+        '1' => 'Errors occurred during processing',
+        '2' => 'An unexpected error occurred during loading / running of the transformation',
+        '3' => 'Unable to prepare and initialize this transformation',
+        '7' => "The transformation couldn't be loaded from XML or the Repository",
+        '8' => 'Error loading steps or plugins (error in loading one of the plugins mostly)',
+        '9' => 'Command line usage printing'
+      }.freeze
+
+      attr_reader :execution
+
+      def initialize(execution)
+        @execution = execution
+
+        message = MESSAGES[execution.code.to_s] || 'Unknown'
+
+        super(message)
+      end
+    end
+  end
+end