racf 0.6.0

data/lib/racf/commands/listgrp/group_members_parser.rb

@@ -0,0 +1,104 @@
+require 'racf/commands/abstract_command'
+
+require 'state_machine'
+
+module Racf
+  module Commands
+    class Listgrp < AbstractCommand
+      class GroupMembersParser
+        attr_reader :members
+
+        state_machine :state, :initial => :nothing_processed do
+          state :nothing_processed, :headers_processed, :first_line_processed,
+                :second_line_processed, :no_members
+
+          state :member_processed, :no_members do
+            def parsed?
+              true
+            end
+          end
+
+          state all - [:member_processed, :no_members] do
+            def parsed?
+              false
+            end
+          end
+
+          event :process_first_line do
+            transition [:headers_processed, :member_processed] => :first_line_processed
+          end
+
+          event :process_second_line do
+            transition :first_line_processed => :second_line_processed
+          end
+
+          event :process_third_line do
+            transition :second_line_processed => :member_processed
+          end
+        end
+
+        def initialize
+          @current_line = nil
+          @members = {}
+          @current_member = nil
+
+          super
+        end
+
+        def parse(line)
+          @current_line = line.strip
+
+          case state_name
+          when :nothing_processed
+            process_headers
+          when :headers_processed, :member_processed
+            process_first_line
+          when :first_line_processed
+            process_second_line
+          when :second_line_processed
+            process_third_line
+          end
+        end
+
+
+        private
+        def process_headers
+          members_header = /USER\(S\)=\s+ACCESS=\s+ACCESS COUNT=\s+UNIVERSAL ACCESS=/
+
+          if @current_line.match(members_header)
+            @state = "headers_processed"
+          elsif @current_line == "NO USERS"
+            @state = "no_members"
+          end
+        end
+
+        def process_first_line
+          member, access, access_count, universal_access = @current_line.split(' ')
+          @current_member = member
+          @members[@current_member] = {
+            :access => access,
+            :access_count => access_count,
+            :universal_access => universal_access
+          }
+
+          super
+        end
+
+        def process_second_line
+          connect_attributes = @current_line.match(/CONNECT ATTRIBUTES=(.*?)$/)[1]
+          @members[@current_member].merge!(:connect_attributes => connect_attributes)
+
+          super
+        end
+
+        def process_third_line
+          revoke_date, resume_date = @current_line.match(/REVOKE DATE=(.*?)\s+RESUME DATE=(.*?)$/)[1..-1]
+          @members[@current_member].merge!(:revoke_date => revoke_date)
+          @members[@current_member].merge!(:resume_date => resume_date)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/racf/commands/listuser.rb

@@ -0,0 +1,112 @@
+require 'strscan'
+require 'state_machine'
+require 'racf/commands/abstract_command'
+
+
+module Racf
+  module Commands
+    class Listuser < AbstractCommand
+      state_machine :state, :initial => :nothing_processed do
+        state :nothing_processed, :name_processed, :user_processed
+
+        event :process_name do
+          transition [:nothing_processed, :user_processed] => :name_processed
+        end
+
+        event :finish_user_parsing do
+          transition :name_processed => :user_processed
+        end
+      end
+
+      def initialize(session)
+        @users = {}
+        @current_user = {}
+
+        super
+      end
+
+      def run(*args)
+        users_ids = extract_users_ids(args)
+        command = "LISTUSER (#{users_ids})"
+        raw_output = @session.run_command(command)
+
+        @scanner = StringScanner.new(raw_output)
+
+        log_number_of_users(@scanner.rest)
+
+        @user_index = 1
+        while @scanner.scan(/(.*?)$\n/)
+          case state_name
+          when :nothing_processed, :user_processed
+            process_name
+          when :name_processed
+            finish_user_parsing
+          end
+        end
+
+        users = @users
+        clear_state
+
+        users
+      end
+
+      def extract_resources(arguments)
+        resources = arguments.first
+
+        case resources
+        when String
+          [resources]
+        when Array
+          resources
+        end
+      end
+
+      private
+      def extract_users_ids(arguments)
+        extract_resources(arguments).join(" ")
+      end
+
+      def log_number_of_users(users_output)
+        @number_of_users = users_output.scan(/USER=.*?NAME=.*?/).size
+        Racf.logger.info("Processing #{@number_of_users} users")
+      end
+
+      def current_line
+        @scanner.matched
+      end
+
+      def process_name
+        if matched_data = current_line.strip.match(/USER=(.*?)\s+NAME=(.*?)\s+OWNER/)
+          Racf.logger.info("Processing user #{@user_index} of #{@number_of_users} users")
+
+          @current_user = {}
+          @current_user[:name] = matched_data[2]
+          user_id = matched_data[1]
+          @users[user_id.to_sym] = @current_user
+
+          Racf.logger.info("\tProcessing user #{user_id}")
+
+          super
+        end
+      end
+
+      def finish_user_parsing
+        while @scanner.scan(/(.*?)$\n/)
+          if current_line.strip =~ /USER=(.*?)\s+NAME=(.*?)\s+OWNER/
+            @scanner.unscan
+            break
+          end
+        end
+
+        @current_user = {}
+        @user_index += 1
+        super
+      end
+
+      def clear_state
+        @users = {}
+        @current_user = {}
+      end
+    end
+  end
+end

data/lib/racf/commands/rlist.rb

@@ -0,0 +1,208 @@
+require 'strscan'
+require 'state_machine'
+require 'racf/commands/abstract_command'
+
+module Racf
+  module Commands
+
+    class Rlist < AbstractCommand
+      NAME_HEADER  = /CLASS\s+NAME/
+      NO_USERS     = /NO\s+USERS\s+IN\s+ACCESS\s+LIST/
+      OWNER_HEADER = /LEVEL\s+OWNER\s+UNIVERSAL\s+ACCESS\s+YOUR\s+ACCESS\s+WARNING/
+      CONDITIONAL_ACCESS_LIST_HEADER = /ID\s+ACCESS\s+ACCESS\s+COUNT\s+CLASS\s+ENTITY\s+NAME/
+
+      state_machine :state, :initial => :nothing_processed do
+        state :nothing_processed, :name_processed, :members_processed,
+              :owner_processed, :users_processed, :resource_processed
+
+        event :process_name do
+          transition [:nothing_processed, :resource_processed] => :name_processed
+        end
+
+        event :process_members do
+          transition :name_processed => :members_processed
+        end
+
+        event :process_owner do
+          transition [:name_processed, :members_processed] => :owner_processed
+        end
+
+        event :process_users do
+          transition :owner_processed => :users_processed
+        end
+
+        event :finish_resource_processing do
+          transition :users_processed => :resource_processed
+        end
+      end
+
+      def initialize(session)
+        @resources = {}
+        @current_resource = {}
+
+        super
+      end
+
+      def run(*args)
+        class_name        = args[0]
+        resources_names   = extract_resources_names(args)
+        command           = "RLIST #{class_name} (#{resources_names}) AUTHUSER"
+
+        raw_output        = @session.run_command(command)
+
+        @scanner = StringScanner.new(raw_output)
+        log_number_of_resources(args[1])
+
+        while @scanner.scan(/(.*?)$\n/)
+          case state_name
+          when :nothing_processed, :resource_processed
+            process_name
+          when :name_processed
+            case class_name
+            when "TIMS"
+              process_owner
+            when "GIMS"
+              process_members
+            end
+          when :members_processed
+            process_owner
+          when :owner_processed
+            process_users
+          when :users_processed
+            finish_resource_processing
+          end
+        end
+
+        resources = @resources
+        clear_state
+
+        resources
+      end
+
+      def extract_resources(args)
+        resources = args[1]
+
+        case resources
+        when String
+          [resources]
+        when Array
+          resources
+        end
+      end
+
+      private
+      def extract_resources_names(arguments)
+        extract_resources(arguments).join(" ")
+      end
+
+      def log_number_of_resources(resources)
+        case resources
+        when String
+          Racf.logger.info("Processing #{resources} resources")
+        when Array
+          Racf.logger.info("Processing #{resources.size} resources")
+        end
+      end
+
+      def current_line
+        @scanner.matched
+      end
+
+      def skip_lines(number_of_lines)
+        number_of_lines.times { @scanner.scan(/(.*?)$\n/) }
+      end
+
+      def process_name
+        if current_line.strip.match(NAME_HEADER)
+          skip_lines(2)
+          matched_data = current_line.strip.match(/.*?\s+(.*?)$/)
+
+          resource_name = matched_data[1]
+          @resources.merge!({ resource_name.to_sym => @current_resource })
+
+          super
+        end
+      end
+
+      def process_members
+        @current_resource[:tims] = []
+
+        if current_line.strip.match(/RESOURCES\s+IN\s+GROUP/)
+          skip_lines(1)
+
+          while @scanner.scan(/(.*?)$\n/)
+            break if current_line.strip.match(OWNER_HEADER) || current_line.strip.match(/NONE/)
+
+            matched_data = current_line.strip.match(/^(.*)$/)
+            @current_resource[:tims] << matched_data[1]
+          end
+
+          @scanner.unscan
+
+          @current_resource[:tims].map!(&:strip)
+          @current_resource[:tims] = @current_resource[:tims].find_all { |tim| !tim.empty? }
+          super
+        end
+      end
+
+      def process_owner
+        if current_line.strip.match(OWNER_HEADER)
+          skip_lines(2)
+          matched_data = current_line.strip.match(/.*?\s+(.*?)\s+.*$/)
+          @current_resource[:owner] = matched_data[1]
+
+          super
+        end
+      end
+
+      def process_users
+        @current_resource[:standard_access_list] = []
+
+        if current_line.strip.match(/USER\s+ACCESS\s+ACCESS\s+COUNT/)
+          skip_lines(1)
+          process_access_list
+
+          super
+        end
+      end
+
+      def process_access_list
+        while @scanner.scan(/(.*?)$\n/)
+          break if current_line.strip.empty? ||
+            current_line.strip.match(NO_USERS) ||
+            current_line.strip.match(CONDITIONAL_ACCESS_LIST_HEADER)
+
+          matched_data = current_line.strip.match(/(.*?)\s+(.*?)\s+.*?$/)
+          user = {
+            :user_or_group => matched_data[1],
+            :authority_level => matched_data[2]
+          }
+
+          @current_resource[:standard_access_list] << user
+        end
+      end
+
+      def finish_resource_processing
+        while @scanner.scan(/(.*?)$\n/)
+          if current_line.nil?
+            break
+          elsif current_line.strip.match(NAME_HEADER)
+            @scanner.unscan
+            break
+          end
+        end
+
+        @current_resource = {}
+
+        super
+      end
+
+      def clear_state
+        @resources = {}
+        @current_resource = {}
+      end
+
+    end
+
+  end
+end

data/lib/racf/commands/search.rb

@@ -0,0 +1,31 @@
+require 'racf/commands/abstract_command'
+
+module Racf
+  module Commands
+    class Search < AbstractCommand
+      # ATENTION: That method deals only with the SEARCH CLASS(TIMS)
+      # and SEARCH CLASS(GIMS) queries
+      #
+      def run(*args)
+        begin
+          command = "SEARCH #{args.first}"
+          response = @session.run_command(command)
+
+          profiles = []
+          response.each_line.each do |line|
+            profiles << line.strip
+          end
+
+          return profiles
+        rescue StandardError => e
+          error_traces = "\t" + e.message + "\n\t" + e.backtrace.join("\n\t")
+          Racf.logger.info("Ooops, an exception was raised!\n#{error_traces}")
+        end
+      end
+
+      def extract_resources(arguments)
+        []
+      end
+    end
+  end
+end