Class: ToolsNet

Inherits:
Object show all
Includes:
Singleton
Defined in:
lib/lib/net.rb

Class Method Summary collapse

Class Method Details

.doreq(restclient_obj, path, method, caller, method_opts: {}, validate_opts: {}, retry_opts: {}, show_progress: false) ⇒ Object

Do the request, validate and decode response and do the retries if needed

  • restclient_obj: initialized RestClient object
  • path: URL path to request
  • method: symbol for HTTP Method to request
  • method_opts: options as passed to a RestClient call
  • validate_opts: options for response validation as used with validate_decode_response()
  • retry_opts: when_res: [nil, [], {}, 'str'], when_code: [404, 500], conditionals to retry even if no exceptions were catched

Parameters:

  • restclient_obj —

    Rest Object

  • path —

    path

  • method —

    method

  • caller —

    caller

  • method_opts (defaults to: {}) —

    method opts

  • validate_opts (defaults to: {}) —

    validate opts

  • retry_opts (defaults to: {}) —

    retry opts

  • show_progress (defaults to: false) —

    default false



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/lib/net.rb', line 60

def self.doreq( restclient_obj, path, method, caller, method_opts: {},validate_opts: {}, retry_opts: {}, show_progress: false)
  res = nil
  code = nil
  data = method_opts.fetch(:data, nil)
  method_opts.delete(:data)

  # Retry loop due to:
  # - 404 from Router API right after applying patch over a target
  # - Intermittent connection reset from Manager API (HTTPS)
  retries = retry_opts.fetch(:attempts, 10)
  1.upto(retries) do |try|
    flag_error = false
    # The request
    begin
      restclient_obj[path].send(method, *data, **method_opts) do |response, request, result|
        res  = validate_decode_response(response, request, result, validate_opts)
        code = result.code.to_i
      end
    rescue Exception => error
      ap error
      flag_error = true
    end
    # Other conditionals to retry
    unless retry_opts.empty?
      if retry_opts.has_key?(:when_res)
        flag_error = true if retry_opts[:when_res].include?(res)
      end
      if retry_opts.has_key?(:when_code)
        flag_error = true if retry_opts[:when_code].include?(code)
      end
    end
    return res unless flag_error # got response, break the loop
    doReqMSG = sprintf "%d/%d", try, retries
    if show_progress
       ap doReqMSG
    end
    if try >= retries
      ap doreq_code
      return nil
    else
      sleep 1 # wait before next
    end
  end
end

.resolv_dns(domain) ⇒ String

Resolv a dns to a ip.

Parameters:

  • domain —

    variable ip to resolv

Returns:

  • (String) —

    Dns address resolved



26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/lib/net.rb', line 26

def self.resolv_dns domain
  begin
    dns = Dnsruby::DNS.new()
    ret = dns.getaddress(domain).to_s
  rescue Exception => e
    case e.message
      when "Dnsruby::NXDomain"
        ret = nil
      else
        ret = e.message
    end
  end
  return ret
end

.resolv_ip_name(ip) ⇒ String

Resolv a ip to a dns.

Parameters:

  • ip —

    variable ip to resolv

Returns:

  • (String) —

    Dns name resolved



10
11
12
13
14
15
16
17
18
19
 
# File 'lib/lib/net.rb', line 10

def self.resolv_ip_name ip
  s = ''
  begin
    ret = Resolv.new.getname(ip)
    return ret.instance_variable_get('@labels').join('.')
  rescue Exception => e
    s = 'edi error: ' + e.message
  end
  return s.strip
end

.validate_decode_response(response, request, result, validate_opts) ⇒ Object type

Return a valid decode response.

Parameters:

  • response
  • request
  • result
  • validate_opts

Returns:

  • (Object type) —

    Array or Proc or String or Error



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/lib/net.rb', line 113

def self.validate_decode_response response, request, result, validate_opts
  if validate_opts.has_key? :expected
    expected = validate_opts[:expected]
    case expected.class.name
    when 'Array'
      if validate_opts[:expected].include? response
        return true
      else
        return false
      end
    when 'Proc'
      response = expected.call(response, request, result)
      return response
    when 'String'
      return result   if validate_opts[:expected].eql? 'result'
      return request  if validate_opts[:expected].eql? 'request'
      return response if validate_opts[:expected].eql? 'response'
    else
      ap expected.class.name
      return response
    end
  else
    return response
  end
  return true
end