Class: ButlerMainframe::HostBase

Inherits:
Object
  • Object
show all
Includes:
ActiveRecord, GenericFunctions
Defined in:
lib/mainframe/host_base.rb,
lib/butler-mainframe.rb

Overview

This is the host class base that contains high level logic It uses sub method that have to be defined in the specific sub class

Direct Known Subclasses

Host

Constant Summary collapse

MAX_TERMINAL_COLUMNS = 
80
MAX_TERMINAL_ROWS = 
24
WAIT_AFTER_START_CONNECTION =

SECONDS

1
WAIT_AFTER_START_SESSION =

SECONDS

3

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from GenericFunctions

#abend?, #catch_abend, #catch_message, #catch_title, #cics?, #cics_selection, #cics_selection?, #company_menu, #company_menu?, #destination_list, #do_confirm, #do_enter, #do_erase, #do_quit, #execute_cics, #go_back, #navigate, #screen_title, #session_login, #session_login?

Methods included from ActiveRecord

#screenshot

Constructor Details

#initialize(options = {}) ⇒ HostBase

Returns a new instance of HostBase.



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/mainframe/host_base.rb', line 17

def initialize(options={})
  options = {
      :session_tag          => ButlerMainframe.configuration.session_tag,
      :wait                 => 0.01,  # wait screen in seconds
      :wait_debug           => 2,     # wait time for debug purpose
      :debug                => false,
      :browser_path         => ButlerMainframe.configuration.browser_path,
      :session_url          => ButlerMainframe.configuration.session_url,
      :session_path         => ButlerMainframe.configuration.session_path,
      :timeout              => ButlerMainframe.configuration.timeout,
      :erase_before_writing => false, # execute an erase until end of field before write a text
      :close_session        => :evaluate
                                #:evaluate    if the session is found will not be closed
                                #:never       never close the session
                                #:always      the session is always closed
  }.merge(options)

  @debug                = options[:debug]
  @wait                 = options[:wait]
  @wait_debug           = options[:wait_debug]
  @session_tag          = options[:session_tag]
  @close_session        = options[:close_session]
  @timeout              = options[:timeout]
  @timeout_screen       = @wait * 1000
  @erase_before_writing = options[:timeout]
  @action               = {}
  @pid                  = nil

  create_object options
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args) ⇒ Object (private)

If is called a not existing method there is the chance that an optional module may not have been added

Raises:

  • (NoMethodError) 


322
323
324
 
# File 'lib/mainframe/host_base.rb', line 322

def method_missing(method_name, *args)
  raise NoMethodError, "Method #{method_name} not found! Please check you have included any optional modules"
end

Instance Attribute Details

#action ⇒ Object (readonly)

Returns the value of attribute action.



9
10
11
 
# File 'lib/mainframe/host_base.rb', line 9

def action
  @action
end

#close_session ⇒ Object

Ends the connection and closes the session



49
50
51
 
# File 'lib/mainframe/host_base.rb', line 49

def close_session
  @close_session
end

#debug ⇒ Object

Returns the value of attribute debug.



10
11
12
 
# File 'lib/mainframe/host_base.rb', line 10

def debug
  @debug
end

#wait ⇒ Object (readonly)

Returns the value of attribute wait.



9
10
11
 
# File 'lib/mainframe/host_base.rb', line 9

def wait
  @wait
end

Instance Method Details

#exec_command(cmd) ⇒ Object

Execute keyboard command like PF1 or PA2 or ENTER …



84
85
86
87
88
 
# File 'lib/mainframe/host_base.rb', line 84

def exec_command(cmd)
  puts "Command: #{cmd}" if @debug
  sub_exec_command cmd
  wait_session
end

#get_cursor_axes ⇒ Object

Return the coordinates of the cursor



158
159
160
 
# File 'lib/mainframe/host_base.rb', line 158

def get_cursor_axes
  sub_get_cursor_axes
end

#quit ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/mainframe/host_base.rb', line 53

def quit
  puts "Closing session with criterion \"#{@close_session}\"" if @debug
  case @close_session
    when :always, :yes
      sub_close_session
      puts "Session closed" if @debug
      wait_session 0.1
    when :never, :no
      if @pid
        puts "Session forced to stay open" if @debug
      else
        puts "Session not closed because it was already existing anyway it would not been closed" if @debug
      end
    when :evaluate
      if @pid
        sub_close_session
        puts "Session closed because started by this process with id #{@pid}" if @debug
        wait_session 0.1
      else
        puts "Session not closed because it was already existing" if @debug
      end
  end
end

#scan(options = {}) ⇒ Object

It reads one line or an area on the screen according to parameters supplied



91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/mainframe/host_base.rb', line 91

def scan(options={})
  options = {
      :y  => nil, :x  => nil, :len => nil,
      :y1 => nil, :x1 => nil, :y2  => nil, :x2 => nil,
  }.merge(options)
  if options[:len]
    scan_row(options[:y], options[:x], options[:len])
  else
    scan_area(options[:y1], options[:x1], options[:y2], options[:x2])
  end
end

#scan_page ⇒ Object

Scans and returns the text of the entire page



104
105
106
 
# File 'lib/mainframe/host_base.rb', line 104

def scan_page
  scan_area(1, 1, MAX_TERMINAL_ROWS, MAX_TERMINAL_COLUMNS)
end

#set_cursor_axes(y, x, options = {}) ⇒ Object

Move the cursor at given coordinates



163
164
165
 
# File 'lib/mainframe/host_base.rb', line 163

def set_cursor_axes(y, x, options={})
  sub_set_cursor_axes(y, x, options)
end

#wait_session(wait = nil) ⇒ Object

Sleep time between operations



79
80
81
 
# File 'lib/mainframe/host_base.rb', line 79

def wait_session(wait=nil)
  sleep(wait || (@debug ? @wait_debug : @wait))
end

#write(text, options = {}) ⇒ Object

Write text on screen at the coordinates Based on the parameters provided it writes a line or an area Options:

:hook                       => nil,
:y                          => nil, #row
:x                          => nil, #column
:check                      => true,
:raise_error_on_check       => true,
:sensible_data              => nil,
:clean_chars_before_writing => nil, # clean x chars before writing a value, it switch off erase_before_writing
:erase_before_writing       => nil  # execute an erase until end of field before write a text



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/mainframe/host_base.rb', line 119

def write(text, options={})
  options = show_deprecated_param(:erase_field_first, :erase_before_writing, options)       if options[:erase_field_first]
  options = show_deprecated_param(:clean_first_chars, :clean_chars_before_writing, options) if options[:clean_first_chars]
  options = {
      :hook                       => nil,
      :y                          => nil,
      :x                          => nil,
      :check                      => true,
      :raise_error_on_check       => true,
      :sensible_data              => nil,
      :clean_chars_before_writing => nil,
      :erase_before_writing       => @erase_before_writing
  }.merge(options)
  options[:erase_before_writing] = false if options[:clean_chars_before_writing]

  y   = options[:y] || get_cursor_axes[0]
  x   = options[:x] || get_cursor_axes[1]

  hooked_rows = 2
  raise "Missing coordinates! y(row)=#{y} x(column)=#{x} "  unless x && y
  raise "Sorry, cannot write null values at y=#{y} x=#{x}"  unless text

  bol_written = false
  if options[:hook]
    (y-hooked_rows..y+hooked_rows).each do |row_number|
      if /#{options[:hook]}/ === scan_row(row_number, 1, MAX_TERMINAL_COLUMNS)
        puts "Change y from #{y} to #{row_number} cause hook to:#{options[:hook]}" if row_number != y && @debug
        bol_written = write_text_on_map(text, row_number, x, options)
        break
      end
    end
  else
    #If no control is required or was not found the label reference
    bol_written = write_text_on_map(text, y, x, options) unless bol_written
  end
  bol_written
end