Module: BlackStack::Netting

Defined in:
lib/functions.rb

Overview

Network

Defined Under Namespace

Classes: ApiCallException

Constant Summary collapse

CALL_METHOD_GET = 
'get'
CALL_METHOD_POST = 
'post'
DEFAULT_SSL_VERIFY_MODE = 
OpenSSL::SSL::VERIFY_NONE
SUCCESS = 
'success'
@@lockfiles = 
[]
@@max_api_call_channels =

0 means infinite

0

Class Method Summary collapse

Class Method Details

.add_param(url, param_name, param_value) ⇒ Object

Add a parameter to the url. It doesn't validate if the param already exists.



819
820
821
822
823
824
825
826
827
828
829
830
831
 
# File 'lib/functions.rb', line 819

def self.add_param(url, param_name, param_value)
  uri = URI(url)
  params = URI.decode_www_form(uri.query || '')
  
  if (params.size==0)
    params << [param_name, param_value]
    uri.query = URI.encode_www_form(params)
    return uri.to_s
  else
    uri.query = URI.encode_www_form(params)
    return uri.to_s + "&" + param_name + "=" + param_value    
  end
end

.api_call(url, params = {}, method = BlackStack::Netting::CALL_METHOD_POST, ssl_verify_mode = BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, max_retries = 5) ⇒ Object

TODO: deprecated



698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# File 'lib/functions.rb', line 698

def self.api_call(url, params={}, method=BlackStack::Netting::CALL_METHOD_POST, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, max_retries=5)
  nTries = 0
  bSuccess = false
  parsed = nil
  sError = ""
  while (nTries < max_retries && bSuccess == false)
    begin
      nTries = nTries + 1
      uri = URI(url)
      res = BlackStack::Netting::call_post(uri, params, ssl_verify_mode) if method==BlackStack::Netting::CALL_METHOD_POST
      res = BlackStack::Netting::call_get(uri, params, ssl_verify_mode) if method==BlackStack::Netting::CALL_METHOD_GET
      parsed = JSON.parse(res.body)
      if (parsed['status']==BlackStack::Netting::SUCCESS)
        bSuccess = true
      else
        sError = "Status: #{parsed['status'].to_s}. Description: #{parsed['value'].to_s}." 
      end
    rescue Errno::ECONNREFUSED => e
      sError = "Errno::ECONNREFUSED:" + e.to_console
    rescue => e2
      sError = "Exception:" + e2.to_console
    end
  end # while

  if (bSuccess==false)
    raise "#{sError}"
  end
end

.call_get(url, params = {}, ssl_verify_mode = BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections = true) ⇒ Object

New call_get



642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
 
# File 'lib/functions.rb', line 642

def self.call_get(url, params = {}, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections=true) 
  uri = URI(url)
  uri.query = URI.encode_www_form(params)
  Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https', :verify_mode => ssl_verify_mode) do |http|
    req = Net::HTTP::Get.new uri
    #req.body = body if !body.nil?
    res = http.request req
    case res
    when Net::HTTPSuccess then res
    when Net::HTTPRedirection then BlackStack::Netting::call_get(URI(res['location']), params, ssl_verify_mode, false) if support_redirections
    else
      res.error!
    end
  end
end

.call_post(url, body = {}, ssl_verify_mode = BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections = true) ⇒ Object

Call the API and return th result.

Unlike Net::HTTP::Post, this method support complex json descriptors in order to submit complex data strucutres to access points. For more information about support for complex data structures, reference to: https://github.com/leandrosardi/mysaas/issues/59

url: valid internet address body: hash of body to attach in the call ssl_verify_mode: you can disabele SSL verification here. max_channels: this method use lockfiles to prevent an excesive number of API calls from each datacenter. There is not allowed more simultaneous calls than max_channels.

TODO: parameter support_redirections has been deprecated.



670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
 
# File 'lib/functions.rb', line 670

def self.call_post(url, body = {}, ssl_verify_mode=BlackStack::Netting::DEFAULT_SSL_VERIFY_MODE, support_redirections=true)
  # issue: https://github.com/leandrosardi/mysaas/issues/59  
  #
  # when ruby pushes hash of hashes (or hash of arrays), all values are converted into strings.
  # and arrays are mapped to the last element only.
  #
  # the solution is to convert each element of the hash into a string using `.to_json` method.
  # 
  # references: 
  # - https://stackoverflow.com/questions/1667630/how-do-i-convert-a-string-object-into-a-hash-object
  # - https://stackoverflow.com/questions/67572866/how-to-build-complex-json-to-post-to-a-web-service-with-rails-5-2-and-faraday-ge
  # 
  # iterate the keys of the hash
  # 
  params = {} # not needed for post calls to access points
  path = URI::parse(url).path
  domain = url.gsub(/#{Regexp.escape(path)}/, '')

  conn = Faraday.new(domain, :ssl=>{:verify=>ssl_verify_mode!=OpenSSL::SSL::VERIFY_NONE})
  ret = conn.post(path, params) do |req|
    req.body = body.to_json
    req.headers['Content-Type'] = 'application/json'
    req.headers['Accept'] =  'application/json'
  end
  ret
end

.change_param(url, param_name, param_value) ⇒ Object

Changes the value of a parameter in the url. It doesn't validate if the param already exists.



834
835
836
837
838
839
840
841
 
# File 'lib/functions.rb', line 834

def self.change_param(url, param_name, param_value)
  uri = URI(url)
#  params = URI.decode_www_form(uri.query || [])
  params = CGI.parse(uri.query)
  params["start"] = param_value
  uri.query = URI.encode_www_form(params)
  uri.to_s
end

.download(url, to) ⇒ Object

Download a file from an url to a local folder. url: must be somedomain.net instead of somedomain.net/, otherwise, it will throw exception. to: must be a valid path to a folder.



730
731
732
733
734
735
736
737
738
739
740
741
 
# File 'lib/functions.rb', line 730

def self.download(url, to)
  uri = URI(url)
  domain = uri.host.start_with?('www.') ? uri.host[4..-1] : uri.host    
  path = uri.path
  filename = path.split("/").last
  Net::HTTP.start(domain) do |http|
    resp = http.get(path)
    open(to, "wb") do |file|
      file.write(resp.body)
    end
  end
end

.file_age(filename) ⇒ Object

returns the age in days of the given file



766
767
768
 
# File 'lib/functions.rb', line 766

def self.file_age(filename)
  (Time.now - File.ctime(filename))/(24*3600)
end

.get_host_without_www(url) ⇒ Object

Removes the 'www.' from an URL.



750
751
752
753
754
 
# File 'lib/functions.rb', line 750

def self.get_host_without_www(url)
  url = "http://#{url}" if URI.parse(url).scheme.nil?
  host = URI.parse(url).host.downcase
  host.start_with?('www.') ? host[4..-1] : host
end

.get_redirect(url) ⇒ Object

Get the final URL if a web page is redirecting.



757
758
759
760
761
762
763
 
# File 'lib/functions.rb', line 757

def self.get_redirect(url)
  uri = URI.parse(url)
  protocol = uri.scheme
  host = uri.host.downcase
  res = Net::HTTP.get_response(uri)
  "#{protocol}://#{host}#{res['location']}"
end

.get_url_extension(url) ⇒ Object

Return the extension of the last path into an URL. Example: get_url_extension("http://connect.data.com/sitemap_index.xml?foo_param=foo_value&quot;) => ".xml"



745
746
747
 
# File 'lib/functions.rb', line 745

def self.get_url_extension(url)
  return File.extname(URI.parse(url).path.to_s)
end

.getDomainFromEmail(email) ⇒ Object 



871
872
873
874
875
876
877
 
# File 'lib/functions.rb', line 871

def self.getDomainFromEmail(email)
  if email.email?
    return email.split("@").last
  else
    raise "getDomainFromEmail: Wrong email format."
  end
end

.getDomainFromUrl(url) ⇒ Object

get the domain from any url



855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
 
# File 'lib/functions.rb', line 855

def self.getDomainFromUrl(url)
  if (url !~ /^http:\/\//i && url !~ /^https:\/\//i) 
    url = "http://#{url}"
  end
  
  if (URI.parse(url).host == nil)
    raise "Cannot get domain for #{url}" 
  end

  if (url.to_s.length>0)
    return URI.parse(url).host.sub(/^www\./, '')
  else
    return nil
  end
end

.getMailHandler(email) ⇒ Object

raise an exception if email is not a valid email address. return an array with the companies who are hosting an email address, by running the linux command host.



912
913
914
915
916
917
918
919
920
921
922
923
924
 
# File 'lib/functions.rb', line 912

def self.getMailHandler(email)
  value = email
  # raise an exception if the data type is an email, but the email is not valid.
  raise "Email #{value} is not valid" if !value.email?
  # extract the domain from the email
  domain = value.split('@').last
  # run the `host` command
  s = `host -t mx #{domain}`
  # extract the domains from the output
  a = s.split("\n").map { |l| l.split.last }
  # extract the company who is hosting the mail
  a.map { |d| d.split('.').last(2).join('.') }.uniq
end

.getWhoisDomains(domain, allow_heuristic_to_avoid_hosting_companies = false) ⇒ Object 



879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
 
# File 'lib/functions.rb', line 879

def self.getWhoisDomains(domain, allow_heuristic_to_avoid_hosting_companies=false)
  a = Array.new
  c = Whois::Client.new
  r = c.lookup(domain)

  res = r.to_s.scan(/Registrant Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
  if (res!=nil)
    a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
  end

  res = r.to_s.scan(/Admin Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
  if (res!=nil)
    a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
  end

  res = r.to_s.scan(/Tech Email: (#{BlackStack::Strings::MATCH_EMAIL})/).first
  if (res!=nil)
    a << BlackStack::Netting::getDomainFromEmail(res[0].downcase)
  end

  # remover duplicados
  a = a.uniq

  # 
  if (allow_heuristic_to_avoid_hosting_companies==true)
    # TODO: develop this feature
  end

  return a
end

.isPersonalEmail?(email) ⇒ Boolean

raise an exception if email is not a valid email address. return if the email domain is gmail, hotmail, outlook, yahoo, comcast, aol, msn or sbcglobal.

Returns:

  • (Boolean) 


928
929
930
931
932
933
934
935
936
 
# File 'lib/functions.rb', line 928

def self.isPersonalEmail?(email)
  value = email
  # raise an exception if the data type is an email, but the email is not valid.
  raise "Email #{value} is not valid" if !value.email?
  # extract the domain from the email
  domain = value.split('@').last
  # 
  return domain=~/gmail\.com/ || domain=~/hotmail\.com/ || domain=~/outlook\.com/ || domain=~/yahoo\.com/ || domain=~/comcast\.com/ || domain=~/aol\.com/ || domain=~/msn\.com/ || domain=~/sbcglobal\.net/ ? true : false
end

.lockfiles ⇒ Object 



613
614
615
 
# File 'lib/functions.rb', line 613

def self.lockfiles()
  @@lockfiles
end

.max_api_call_channels ⇒ Object 



609
610
611
 
# File 'lib/functions.rb', line 609

def self.max_api_call_channels()
  @@max_api_call_channels
end

.params(url) ⇒ Object

returns a hash with the parametes in the url



806
807
808
809
810
811
812
813
814
815
816
 
# File 'lib/functions.rb', line 806

def self.params(url)
  # TODO: Corregir este parche:
  # => El codigo de abajo usa la URL de una busqueda en google. Esta url generara una excepcion cuando se intenta parsear sus parametros.
  # => Ejecutar las 2 lineas de abajo para verificar.
  # => url = "https://www.google.com/webhp#q=[lead+generation]+%22John%22+%22Greater+New+York+City+Area+*+Financial+Services%22+site:linkedin.com%2Fpub+-site:linkedin.com%2Fpub%2Fdir"
  # => p = CGI::parse(URI.parse(url).query)
  # => La linea de abajo hace un gsbub que hace que esta url siga funcionando como busqueda de google, y ademas se posible parsearla.
  url = url.gsub("webhp#q=", "webhp?q=")

  return CGI::parse(URI.parse(url).query)
end

.set(h) ⇒ Object 



617
618
619
620
621
622
623
624
625
626
 
# File 'lib/functions.rb', line 617

def self.set(h)
  @@max_api_call_channels = h[:max_api_call_channels]
  @@lockfiles = []
  
  i = 0
  while i<@@max_api_call_channels
    @@lockfiles << File.open("./apicall.channel_#{i.to_s}.lock", "w")
    i+=1
  end
end

.set_param(url, param_name, param_value) ⇒ Object

Change or add the value of a parameter in the url, depending if the parameter already exists or not.



844
845
846
847
848
849
850
851
852
 
# File 'lib/functions.rb', line 844

def self.set_param(url, param_name, param_value)
  params = BlackStack::Netting::params(url) 
  if ( params.has_key?(param_name) == true )
    newurl = BlackStack::Netting::change_param(url, param_name, param_value)
  else
    newurl = BlackStack::Netting::add_param(url, param_name, param_value)
  end
  return newurl
end