racf 0.6.0

data/lib/racf/pagers/cached_ispf_pager.rb

@@ -0,0 +1,91 @@
+require 'racf/pagers/ispf_pager'
+
+module Racf
+  module Pagers
+    class CachedIspfPager
+      attr_accessor :cache
+
+      def initialize(command, uncached_pager=IspfPager)
+        @command = command
+        @pager   = uncached_pager.new @command
+        @cache   = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      def run(*arguments)
+        resources = @command.extract_resources(arguments)
+
+        if resources.empty?
+          @pager.run(*arguments)
+        else
+          run_cached(arguments, resources)
+        end
+      end
+
+      private
+
+      def run_cached(arguments, resources)
+        merged_results = {}
+
+        @other_arguments = arguments.flatten - resources
+
+        merged_results.merge! cached_results(resources)
+        merged_results.merge! uncached_results(resources)
+
+        merged_results
+      end
+
+      def cached_results(resources)
+        cached_resources = cached_resources(resources)
+
+        unless cached_resources.empty?
+          Racf.logger.info "Loading data from the cache: #{cached_resources.join(', ')}"
+        end
+
+        items = cached_resources.map do |resource|
+          [resource.to_sym, current_cache[resource]]
+        end
+
+        Hash[items]
+      end
+
+      def cached_resources(resources)
+        current_cache.keys & resources
+      end
+
+      def uncached_results(resources)
+        uncached_resources = uncached_resources(resources)
+
+        if !uncached_resources.empty?
+          Racf.logger.info("Data not on cache, try to retrieve it from origin: #{uncached_resources.join(', ')}")
+
+          run_pager(uncached_resources).tap do |results|
+            add_to_cache(results)
+          end
+        else
+          {}
+        end
+      end
+
+      def uncached_resources(resources)
+        resources - current_cache.keys
+      end
+
+      def add_to_cache(results)
+        string_results = results.map { |key, value| [key.to_s, value] }
+        results_hash = Hash[string_results]
+
+        @cache[@other_arguments].merge! results_hash
+      end
+
+      def current_cache
+        @cache[@other_arguments]
+      end
+
+      def run_pager uncached_resources
+        uncached_parameters = @other_arguments + [uncached_resources]
+        @pager.run(*uncached_parameters)
+      end
+
+    end
+  end
+end

data/lib/racf/pagers/ispf_pager.rb

@@ -0,0 +1,57 @@
+module Racf
+  module Pagers
+    class IspfPager
+      # From the ISPF command shell help, restrictions part:
+      # "(234 characters is the maximum allowed, including command name)"
+      # Setting that constant limit should deal with that restriction
+      ISPF_INPUT_LIMIT = 20
+
+      def initialize(command)
+        @command = command
+      end
+
+      def run(*arguments)
+        resources = @command.extract_resources(arguments)
+
+        if resources.empty?
+          @command.run(*arguments)
+        else
+          paginated(arguments, resources)
+        end
+      end
+
+      private
+
+      def paginated(arguments, resources)
+        results = {}
+
+        total = resources.size
+        slice_counter = 0
+
+        other_arguments = arguments.flatten - resources
+
+        resources.each_slice(ISPF_INPUT_LIMIT) do |slice|
+          log_slice(slice_counter, total)
+
+          command_arguments = other_arguments + [slice]
+          results.merge! @command.run(*command_arguments)
+
+          slice_counter += 1
+        end
+
+        results
+      end
+
+      def log_slice(slice_index, total)
+        interval_start = (ISPF_INPUT_LIMIT * slice_index) + 1
+
+        interval_end = (slice_index + 1) * ISPF_INPUT_LIMIT
+        if interval_end > total
+          interval_end = total
+        end
+
+        Racf.logger.info("\tRetrieving #{interval_start} - #{interval_end} of #{total}")
+      end
+    end
+  end
+end

data/lib/racf/s3270.rb

@@ -0,0 +1,136 @@
+require 'net/telnet'
+
+# Wrapper around s3270 daemon (http://x3270.bgp.nu/).
+# S3270 is a scriptable emulator of a mainframe terminal
+#
+class S3270
+  DEFAULT_LOG_DIR = File.expand_path("../../../log", __FILE__)
+
+  def initialize(host="127.0.0.1", host_port="3270", verbose=false, script_port="3003", telnet_timeout=30)
+    @host = host
+    @host_port = host_port
+    @script_port = script_port
+    @verbose = verbose
+    @telnet_timeout = telnet_timeout
+
+    open_connection
+    register_exit_hook
+  end
+
+  # Runs a s2370 action
+  #
+  def action(command)
+    # TODO check standarderror
+    # From the x3270-script manual page (http://x3270.bgp.nu/x3270-script.html):
+    # " If an error occurs in processing an action, the usual pop-up
+    #   window does not appear. Instead, the text is written to standard output."
+    @connection.cmd(command)
+  end
+
+  # Puts a string command in the screen and press enter
+  #
+  def string_action(command)
+    self.action("string(\"#{command}\")")
+    self.action("enter")
+  end
+
+
+  # Closes the s3270 daemon and the telnet connection on its script port
+  #
+  def close
+    self.action("quit")
+    @connection.close
+  end
+
+  # Returns the current screen of the terminal
+  #
+  def screen
+    self.action("ascii")
+  end
+
+  # Returns the content of a set of paginated screens
+  #
+  def complete_screen
+    screen, has_next_page = clean_screen_metadata
+
+    while has_next_page
+      self.action("enter")
+      next_screen, has_next_page = clean_screen_metadata
+      screen << "\n#{next_screen}"
+    end
+
+    screen.strip!
+    screen.sub!(/\*\*\*$/, '')
+    screen.strip! || screen
+  end
+
+  private
+    # Opens a telnet connection with the daemon
+    #
+    def open_connection
+      @connection ||= begin
+        raise "It was not possible to run s3270" unless run_s3270_daemon
+        sleep(3)
+
+        Net::Telnet.new(telnet_options)
+      end
+    end
+
+    def run_s3270_daemon
+      if @verbose
+        s3270_command = "s3270 #{@host}:#{@host_port} -scriptport #{@script_port} -trace -tracefile #{File.join(DEFAULT_LOG_DIR, "s3270-trace.log")} &"
+      else
+        s3270_command = "s3270 #{@host}:#{@host_port} -scriptport #{@script_port} &"
+      end
+
+      system(s3270_command)
+    end
+
+    # Return paginated terminal screens without the emulator metadata
+    #
+    def clean_screen_metadata
+      raw_output = self.action("ascii")
+      raw_output.gsub!(/data: /, '')
+      raw_output.gsub!(/\s+\n/, "\n")
+      content = raw_output.split("\n")
+
+      success_message = content.delete_at(-1)
+      status_message = content.delete_at(-1)
+
+      has_next_page = nil
+      if content[-1] =~ /\*\*\*/
+        has_next_page = content.delete_at(-1)
+      end
+
+      [content.join("\n"), has_next_page]
+    end
+
+    def register_exit_hook
+      trap("INT") do
+        unless @connection.closed?
+          close
+        end
+      end
+    end
+
+    def telnet_options
+      if @verbose
+        default_telnet_options.merge(verbose_telnet_options)
+      else
+        default_telnet_options
+      end
+    end
+
+    def default_telnet_options
+      {
+        "Host"    => "127.0.0.1",
+        "Port"    => @script_port,
+        "Prompt"  => /^ok|^error/,
+        "Timeout" => @telnet_timeout
+      }
+    end
+
+    def verbose_telnet_options
+      { "Dump_log" => File.join(DEFAULT_LOG_DIR, "telnet-output.log") }
+    end
+end

data/lib/racf/session.rb

@@ -0,0 +1,149 @@
+require 'racf/s3270'
+require 'time'
+
+module Racf
+  LoginError = Class.new(StandardError)
+
+  class Session
+    DEFAULT_SERVER_PORT = 23
+    DEFAULT_SCRIPT_PORT = '7060'
+
+    attr_reader :last_error_message
+
+    def initialize(options)
+      @user_id        = options[:user_id]
+      @password       = options[:password]
+      @server_address = options[:server_address]
+      @verbose        = options[:verbose]
+      @telnet_timeout        = options[:telnet_timeout]
+      @server_port    = options[:server_port] || DEFAULT_SERVER_PORT
+      @script_port    = options[:script_port] || DEFAULT_SCRIPT_PORT
+
+      @scraper        = options[:scraper] || default_scraper
+    end
+
+    # Start a ISPF shell session
+    #
+    def start
+      Racf.logger.info("Starting RACF session")
+      login
+      load_ispf_shell
+    end
+
+    # Go out of ISPF shell and logoff from mainframe
+    #
+    def finish
+      Racf.logger.info("Closing RACF session")
+      @scraper.action("pf 3")
+      @scraper.string_action("X")
+      @scraper.string_action("logoff")
+      @scraper.close # a action quit faz o emulador dar exit
+      Racf.logger.info("RACF session closed")
+    end
+
+    # Runs a RACF command and returns its raw output
+    #
+    def run_command(command)
+      Racf.logger.info("Executing RACF '#{command}'")
+
+      @scraper.string_action(command)
+      raw_response = @scraper.complete_screen
+      @scraper.action("enter")
+
+      Racf.logger.info("Finished executing RACF '#{command}'")
+
+      screen_without_menu = remove_ispf_menu(raw_response)
+      screen_without_menu
+    end
+
+    # TODO
+    # Remove from the public API. In order to do it, it's neeeded to
+    # improve the design. #theClientIsPushingUs
+    def remove_ispf_menu(screen)
+      if screen.lines.first =~ /Menu\s+List\s+Mode\s+Functions\s+Utilities\s+Help/
+        screen = screen.drop(8)
+        screen = screen.drop_while { |line| line.match(/.*?=>.*?$/) }
+      end
+
+      screen = screen.to_s
+
+      if screen =~ /Menu\s+List\s+Mode\s+Functions\s+Utilities\s+Help/
+        screen.gsub!(/Menu\s+List\s+Mode\s+Functions\s+Utilities\s+Help.*/m, '')
+      end
+
+      screen.strip!
+      screen
+    end
+
+    private
+      def default_scraper
+        S3270.new(@server_address, @server_port, @verbose, @script_port, @telnet_timeout)
+      end
+
+      def login
+        @scraper.string_action("TA")
+
+        Racf.logger.info("Trying to login...")
+
+        @scraper.string_action(@user_id)
+        wait_for_text_on_screen("Enter LOGON parameters below")
+        @scraper.string_action(@password)
+        @scraper.action("enter")
+
+        sleep(2) # make sure there's time for login to complete
+
+        if has_login_error?
+          @scraper.string_action("logoff")
+          @scraper.close
+          Racf.logger.info("Tried to login, but #{last_error_message}")
+          raise LoginError, last_error_message
+        end
+
+        return true
+      end
+
+      def has_login_error?
+        user_already_logged_in? || user_has_expired_password? || user_has_not_authorized_password?
+      end
+
+      def user_already_logged_in?
+        if @scraper.screen.match(/LOGON\s+rejected,\s+UserId\s+(.*?)\s+already\s+logged\s+on/i)
+          @last_error_message = "User #{@user_id} already logged in"
+        end
+      end
+
+      def user_has_expired_password?
+        if @scraper.screen.match(/CURRENT\s+PASSWORD\s+HAS\s+EXPIRED/)
+          @last_error_message = "Password for user #{@user_id} has expired"
+        end
+      end
+
+      def user_has_not_authorized_password?
+        if @scraper.screen.match(/PASSWORD\s+NOT\s+AUTHORIZED\s+FOR\s+USERID/)
+          @last_error_message = "Password for user #{@user_id} is not authorized"
+        end
+      end
+
+      def load_ispf_shell
+        Racf.logger.info("Loading ISPF shell")
+        wait_for_text_on_screen('ISPF/PDF')
+        @scraper.string_action("6")
+        Racf.logger.info("ISPF shell loaded")
+      end
+
+      def wait_for_text_on_screen(text)
+        screen = @scraper.complete_screen
+
+        cicles_index = 0
+        until screen.match(text)
+          cicles_index += 1
+          sleep(0.25)
+          Racf.logger.info("\twaiting for text '#{text}' appear in the screen")
+          screen = @scraper.screen
+        end
+
+        Racf.logger.info("Text '#{text}' appeared in the screen")
+        Racf.logger.info("Waited #{cicles_index * 0.25} seconds for the '#{text}' appear in the screen")
+      end
+  end
+end

data/lib/racf/version.rb

@@ -0,0 +1,3 @@
+module Racf
+  VERSION = "0.6.0"
+end

data/racf.gemspec

@@ -0,0 +1,16 @@
+require File.expand_path('../lib/racf/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Hugo Barauna"]
+  gem.email         = ["hugo.barauna@autoseg.com"]
+  gem.summary       = %q{A wrapper around IBM's Resource Access Control Facility}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "racf"
+  gem.require_paths = ["lib"]
+  gem.version       = Racf::VERSION
+
+  gem.add_dependency "state_machine", "~> 1.1.0"
+end