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, 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

  • 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



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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/lib/net.rb', line 79

def self.doreq( restclient_obj, path, method, 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
      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

.get_current_ip ⇒ Object 



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

def self.get_current_ip
  # begin
  #   ip = Socket::getaddrinfo(Socket.gethostname, "echo", Socket::AF_INET)[0][3]
  #   return ip if IPAddress.valid?(ip)
  # rescue Exception => e
  # end
  ip = `ifconfig | grep -E '10\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}'  | awk '{print $2}'`
  ip = ip.split("\n").first if ip.include? "\n"
  return ip if IPAddress.valid?(ip)
end

.is_backend?(original_addr) ⇒ Boolean

Validate.: ip number is a backend?.

Parameters:

  • original_addr —

    number to be validate.

Returns:

  • (Boolean) 


226
227
228
229
 
# File 'lib/lib/net.rb', line 226

def self.is_backend? original_addr
  glbbackend  = NetAddr::CIDR.create('10.0.0.0/8')
  return glbbackend.contains? original_addr
end

.ping?(host) ⇒ Boolean

Returns:

  • (Boolean) 


5
6
7
 
# File 'lib/lib/net.rb', line 5

def self.ping? host
  return Net::Ping::External.new(host || '0.0.0.1000', timeout=1).ping?
end

.resolv_dns(domain) ⇒ String

Resolv a dns to a ip.

Parameters:

  • domain —

    variable ip to resolv

Returns:

  • (String) —

    Dns address resolved



46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/lib/net.rb', line 46

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"
        return nil
      else
        return 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



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

def self.resolv_ip_name ip
  s = ''
  begin
    ret = Resolv.new.getname(ip)
    return ret.instance_variable_get('@labels').join('.')
  rescue Exception => e
    case e.message
      when "Dnsruby::NXDomain"
        return nil
      else
        return e.message
    end
  end
  return s.strip
end

.valid_ip?(original_addr) ⇒ Boolean

Returns:

  • (Boolean) 


231
232
233
234
235
236
237
238
 
# File 'lib/lib/net.rb', line 231

def self.valid_ip? original_addr
  status = false
  begin
    status = IPAddress.valid?(original_addr)
  rescue
  end
  return status
end

.valid_network?(original_addr) ⇒ Boolean

Validate.: ip number is avalid network.

Parameters:

  • original_addr —

    network number to be validate.

Returns:

  • (Boolean) 


244
245
246
247
248
249
250
251
252
 
# File 'lib/lib/net.rb', line 244

def self.valid_network? original_addr
  status = false
  begin
    ip = IPAddress original_addr
    status = true if ip.network?
  rescue
  end
  return status
end

.valid_port?(port) ⇒ Boolean

Validate.: port number between valid range?.

Parameters:

  • port —

    number to be validate.

Returns:

  • (Boolean) 


162
163
164
165
166
167
168
169
170
 
# File 'lib/lib/net.rb', line 162

def self.valid_port? port
  if port.to_s.strip.match(/^\d{1,5}(?!\d)$/).nil?
    return false
  end
  unless port.to_i.between?(1, 65535)
    return false
  end
  return true
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



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/lib/net.rb', line 130

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

.validate_ipaddress(that) ⇒ Hash

Validate.: ip number or mask are valids?.

Parameters:

  • that —

    number or mask to be validate.

Returns:

  • (Hash) —

    result info ip or ask or error



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/lib/net.rb', line 178

def self.validate_ipaddress that
  result = {}
  result[:status]  = false
  result[:type]    = ''
  result[:msg]     = ''
  result[:address] = that
  result[:resolv]  = ''

  if IPAddress::valid_ipv4? that
    begin
      ip = IPAddress::valid_ipv4? that
      result[:status] = true
      result[:type]   = 'ip'
      result[:oct1]   = that.split('.')[0]
      result[:oct2]   = that.split('.')[1]
      result[:oct3]   = that.split('.')[2]
      result[:oct4]   = that.split('.')[3]
    rescue Exception => e
      result[:msg]    = e.to_s
      return
    end
  else
    begin
      net = NetAddr::CIDR.create that
      result[:type]   = 'mask'
      result[:status] = true
    rescue Exception => e
      ip = resolv_dns that
      if IPAddress::valid_ipv4? ip
        result[:status] = true
        result[:type]   = 'ip'
        result[:oct1]   = ip.split('.')[0]
        result[:oct2]   = ip.split('.')[1]
        result[:oct3]   = ip.split('.')[2]
        result[:oct4]   = ip.split('.')[3]
      else
        result[:msg] = e.to_s
      end
    end
  end
  return result
end