sentofu 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32c5cc4788ad456cd8121cb497ec1edd2646414cc2006466d18cef63c14d3d12
-  data.tar.gz: d681e4a0b6c3d95a3ad2bf6e3a50da249c3876503fb1cd057bd5e94fe94f2e58
+  metadata.gz: ec10af5cec1acf4c593f766637358a1cc323665bf65cde68c5c727c637582f7f
+  data.tar.gz: e75a6edec73c0c0faa5cc7e9a8657f9d348a25bbcc023d3422b4f62dd9e89a5e
 SHA512:
-  metadata.gz: 67f28338c633693c0d2bff8157beab313be3d9a07c6b9ecacd7652710ff3282d3fac42a11f3e6e1973374486f1fb6fa13d4ce1472ca958ae2e2fb3cb3a683823
-  data.tar.gz: e895b60701e76e2f2a50791b3727caa611d6da06bc84e05ef7be7c222531994b25ad3ae48c9c94d38eddfcf2d2a00124ab734166f9ad1bc49d3998c42d05b006
+  metadata.gz: 7e8145180ed891775ef9cf4358778091d18fe5f4199cf2c87a899de9ec14e5ab3a60d18cfa93314a3417660a3a2cb34757bedcaefc0d6b51f5da862659f9836a
+  data.tar.gz: 2f3a1bf05a54b680bdf6247ea2c9b72cac64a590586341476d9b90fe2c2b27986bbcd32d55f94e190fda85d13ffca4daa5a005930abc50e3f2855ea642b44ee0

data/CHANGELOG.md

@@ -2,7 +2,12 @@
 # CHANGELOG.md
 
 
+## sentofu 0.1.0  released 2019-05-23
+
+* Initial implementation
+
+
 ## sentofu 0.0.1  released 2019-05-19
 
-* initial empty release
+* Initial empty release
 

data/Makefile

@@ -40,5 +40,15 @@ test: spec
 
 ## specific to project ##
 
-.PHONY: count_lines scan gemspec_validate name cw build push spec
+detail_apis:
+	time bundle exec ruby -I lib -r yaml -r sentofu -e "puts YAML.dump(Sentofu.detail_apis)"
+list_apis:
+	time bundle exec ruby -I lib -r yaml -r sentofu -e "puts YAML.dump(Sentofu.list_apis)"
+dump_apis:
+	time bundle exec ruby -I lib -r sentofu -e "Sentofu.dump_apis"
+
+
+## done ##
+
+.PHONY: count_lines scan gemspec_validate name cw build push spec detail_apis list_apis dump_apis
 

data/lib/sentofu.rb

@@ -1,21 +1,112 @@
 
 require 'json'
 require 'yaml'
+require 'time'
 require 'base64'
 require 'ostruct'
 require 'net/http'
 
 require 'sentofu/http'
 require 'sentofu/api'
+require 'sentofu/explo'
 
 
 module Sentofu
 
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 
-  Dir[File.join(__dir__, 'sentofu/sentifi-*.yaml')].each do |fpath|
+  USER_AGENT =
+    "Sentofu #{Sentofu::VERSION} - " +
+    [ 'Ruby', RUBY_VERSION, RUBY_RELEASE_DATE, RUBY_PLATFORM ].join(' ')
+  @user_agent =
+    USER_AGENT
 
-    Sentofu::Api.make(YAML.load(File.read(fpath)))
+  @auth_uri = nil
+  @apis = {}
+
+  class << self
+
+    attr_reader :auth_uri, :apis
+    attr_accessor :user_agent
+
+    def init(versions=%w[ common:1.0.0 company:1.0.0 markets:1.0.0 ])
+
+      vers = split_versions(versions)
+
+      vers << %w[ auth * ] unless vers.find { |n, _| n == 'auth' }
+
+      vers.each do |api_name, ver_pattern|
+
+        doc_uri =
+          'https://api.swaggerhub.com/apis/sentifi-api-docs' +
+          (api_name == 'auth' ?
+            '/sentifi-api_o_auth_2_authentication_and_authorization/' :
+            "/sentifi-intelligence_#{api_name}_api/")
+
+        metas = Sentofu::Http.get_and_parse(doc_uri)
+
+        v, u, meta = metas['apis']
+          .collect { |m|
+            prs = m['properties']
+            [ prs.find { |pr| pr['type'] == 'X-Version' }['value'],
+              prs.find { |pr| pr['type'] == 'Swagger' }['url'],
+              m ] }
+          .select { |v, _, _| version_match(v, ver_pattern) }
+          .sort_by(&:first)
+          .first
+
+        spec = Sentofu::Http.get_and_parse(u)
+        spec[:meta] = meta
+
+        if api_name == 'auth'
+          @auth_uri = spec['servers'][0]['url'] + spec['paths'].keys.first
+        else
+          api = Sentofu::Api.new(api_name, spec)
+          Sentofu.define_singleton_method(api_name) { api }
+          @apis[api_name] = api
+        end
+      end
+    end
+
+    def credentials=(cs)
+
+      apis.each { |_, api| api.credentials = cs }
+    end
+
+    protected
+
+    def split_versions(vs)
+
+      case vs
+      when Array
+        vs
+          .select { |v| v.strip.length > 0 }
+          .collect { |v| split_version(v) }
+      when String
+        vs.split(/[,;]/)
+          .select { |v| v.strip.length > 0 }
+          .collect { |v| split_version(v) }
+      else
+        vs
+      end
+    end
+
+    def split_version(v)
+
+      v.is_a?(Array) ? v : v.split(':').collect(&:strip)
+    end
+
+    def version_match(version, pattern)
+
+      ves = version.split('.')
+      pattern.split('.').each do |pa|
+        ve = ves.shift
+        next if pa == 'x' || pa == '*'
+        return false if ve != pa
+      end
+
+      true
+    end
   end
 end
 
@@ -31,7 +122,13 @@ if $0 == __FILE__
   #pp y['paths'].keys
 
   #p Sentofu.company.class
-  p Sentofu.company.topic_search
+  #p Sentofu.company.topic_search
   #pp Sentofu.markets
+
+  #puts Sentofu.company.paths.keys
+
+  t0 = Time.now
+  Sentofu.init
+  puts "took #{Time.now - t0}s..."
 end
 

data/lib/sentofu/api.rb

@@ -3,6 +3,8 @@ module Sentofu
 
   class Resource
 
+    TVP = '_sentofu_' # THREAD VARIABLE PREFIX
+
     attr_reader :parent, :segment
 
     def initialize(parent, segment)
@@ -14,20 +16,22 @@ module Sentofu
 
     def add_segment(segment)
 
-      m = segment.match(/\A\{([^}]+)\}\z/)
+      m = segment.match(/\A\{[^}]+\}\z/)
       mth = m ? :[] : segment
 
       return @children[mth] if @children[mth]
 
+      res = @children[mth] = Sentofu::Resource.new(self, segment)
+
       if mth == :[]
-        @children[:[]] = res = Sentofu::Resource.new(self, m[1])
-        define_singleton_method(:[]) { |i| res.index = i; res }
-        res
+        define_singleton_method(:[]) { |i|
+          Thread.current.thread_variable_set(TVP + segment, i); res }
       else
-        @children[mth] = res = Sentofu::Resource.new(self, segment)
-        define_singleton_method(mth) { res }
-        res
+        define_singleton_method(mth) {
+          res }
       end
+
+      res
     end
 
     def add_leaf_segment(segment, point)
@@ -45,49 +49,105 @@ module Sentofu
 
     def fetch(segment, point, index, query)
 
-p [ :fetch, segment, '(point)', index, query ]
-p path(segment)
+#p [ :fetch, segment, '(point)', index, query ]
+#p path(segment)
 #pp point
-      self.index = index if index
+      Thread.current.thread_variable_set(TVP + segment, index) if index
+
+      q = rectify_query_parameters(point, query)
+
+      pa = File.join(path, segment)
+      pa = pa.gsub(/_/, '-')
+
+      pa = pa + '?' + URI.encode_www_form(q) if q.any?
 
-      validate_query_parameters(point, query)
+      return query.merge(path: pa) if query[:debug]
 
-nil
+      JSON.parse(Sentofu::Http.get(pa, api.token).body)
     end
 
-    def path(segment=nil)
+    def path
 
-      segment ||= self.segment
-      segment = segment.gsub(/_/, '-')
+      seg =
+        segment[0, 1] == '{' ?
+        Thread.current.thread_variable_get(TVP + segment).to_s :
+        segment
 
       if parent
-        File.join(parent.send(:path), segment)
+        File.join(parent.send(:path), seg)
       else
-        '/' + segment
+        seg
       end
     end
 
-    def validate_query_parameters(point, query)
+    def rectify_query_parameters(point, query)
+
+      q = query
+        .inject({}) { |h, (k, v)|
+          next h if k == :debug
+          h[k.to_s.gsub(/_/, '-')] =
+            case v
+            when Symbol then v.to_s
+            when Array then v.collect(&:to_s).join(',')
+            #when Time, Date then v.utc.strftime('%F')
+            when Time, Date then v.strftime('%F')
+            else v
+            end
+          h }
+
+      point['get']['parameters']
+        .each { |par|
+
+          next if par['in'] != 'query'
+
+          nam = par['name']
+          key = nam.gsub(/-/, '_')
+
+          fail ArgumentError.new(
+            "missing query parameter :#{key}"
+          ) if par['required'] == true && !q.has_key?(nam)
+
+          v = q[nam]
+          typ = par['schema']['type']
+
+          fail ArgumentError.new(
+            "argument to :#{key} not an integer"
+          ) if v && typ == 'integer' && ! v.is_a?(Integer)
+          fail ArgumentError.new(
+            "argument to :#{key} not a string (or a symbol)"
+          ) if v && typ == 'string' && ! v.is_a?(String)
+
+          enu = par['schema']['enum']
+
+          fail ArgumentError.new(
+            "value #{v.inspect} for :#{key} not present in #{enu.inspect}"
+          ) if v && enu && ! enu.include?(v) }
+
+      q
+    end
+
+    def api
 
-      point['get']['parameters'].select { |pa| pa['in'] == 'query' }
-        .each { |pa|
-          k = (pa[:key] ||= pa['name'].gsub(/-/, '_').to_sym)
-          fail ArgumentError.new("missing query parameter #{k.inspect}") \
-            if pa['required'] == true && !query.has_key?(k) }
-pp params
+      parent ? parent.api : self
     end
   end
 
   class Api < Resource
 
     attr_reader :spec
+    attr_accessor :credentials
 
-    def initialize(spec, name)
+    def initialize(name, spec)
 
-      super(nil, nil)
+      super(nil, spec['servers'].first['url'])
 
-      @spec = spec
       @name = name
+      @spec = spec
+
+      @credentials = nil
+      @token = nil
+
+      inflate_parameters
 
 #puts "================== #{name}"
       spec['paths'].each do |path, point|
@@ -103,17 +163,71 @@ pp params
       end
     end
 
-    class << self
+    def token
 
-      def make(api_spec)
+      if @token && @token.not_expired?
+        @token
+      else
+        @token = Sentofu::Http.fetch_token(@credentials)
+      end
+    end
+
+    def paths
+
+      @spec['paths']
+    end
+
+    def query(path, params={})
+
+      pa = server + path
+      pa = pa + '?' + URI.encode_www_form(params) if params.any?
+
+      return params.merge(path: pa) if params[:debug]
+
+      JSON.parse(Sentofu::Http.get(pa, token).body)
+    end
 
-        name =
-          api_spec['info']['title'].split(' - ').last[0..-4].strip
-            .gsub(/([a-z])([A-Z])/) { |_| $1 + '_' + $2.downcase }
-            .gsub(/([A-Z])/) { |c| c.downcase }
+    def modified
 
-        api = Sentofu::Api.new(api_spec, name)
-        (class << Sentofu; self; end).define_method(name) { api }
+      Time.parse(
+        @spec[:meta]['properties']
+          .find { |pr| pr['type'] == 'X-Modified' }['value'])
+    end
+
+    def version
+
+      @spec[:meta]['properties']
+        .find { |pr| pr['type'] == 'X-Version' }['value']
+    end
+
+    protected
+
+    def server
+
+      @spec['servers'].first['url']
+    end
+
+    def inflate_parameters
+
+      pars = @spec['components']['parameters']
+      return unless pars
+
+      refs = pars
+        .inject({}) { |h, (k, v)|
+          h["#/components/parameters/#{k}"] = v
+          h }
+
+      @spec['paths'].each do |_, pa|
+        pa.each do |_, me|
+          next unless me['parameters']
+          me['parameters'] = me['parameters']
+            .collect { |pm|
+              if ref = pm['$ref']
+                refs[ref] || fail("found no $ref #{ref.inspect} in spec")
+              else
+                pm
+              end }
+        end
       end
     end
   end

data/lib/sentofu/explo.rb

@@ -0,0 +1,47 @@
+
+module Sentofu
+
+  class << self
+
+    def list_apis
+
+      detail_apis['apis']
+        .collect { |meta|
+
+          ps = meta['properties']
+
+          u = ps.find { |p| p['type'] == 'Swagger' }['url']
+          v = ps.find { |p| p['type'] == 'X-Version' }['value']
+
+          m = u.match(/intelligence_([^_]+)_api/)
+          n = m ? m[1] : meta['name']
+
+          d = meta['description']
+
+          { 'n' => n, 'v' => v, 'd' => d, 'u' => u } }
+    end
+
+    def detail_apis
+
+      Sentofu::Http.get_and_parse(
+        'https://api.swaggerhub.com/apis/sentifi-api-docs/')
+    end
+
+#-	curl https://api.swaggerhub.com/apis/sentifi-api-docs/sentifi-intelligence_company_api/1.0.0/swagger.yaml > api_company.yaml
+    def dump_apis
+
+      puts
+
+      list_apis.each do |h|
+        n = h['n']; n = "auth" if n.match(/auth/i)
+        fn = "api_#{n}_#{h['v']}.yaml"
+        res = Sentofu::Http.get(h['u'] + '/swagger.yaml')
+        File.open(fn, 'wb') { |f| f.write(res.body) }
+        puts "  wrote #{fn}"
+      end
+    end
+
+    #protected
+  end
+end
+

data/lib/sentofu/http.rb

@@ -3,39 +3,71 @@ module Sentofu
 
   module Http
 
-    HOST = 'apis.sentifi.com'
-
     class << self
 
       def fetch_token(credentials=nil)
 
+        u = URI(Sentofu.auth_uri)
+
         cs = narrow_credentials(credentials)
 
         a = Base64.encode64("#{cs.id}:#{cs.secret}").strip
         #p a
 
-        req = Net::HTTP::Post.new('/v1/oauth/token')
+        req = Net::HTTP::Post.new(u.path)
         req.add_field('Content-Type', 'application/json')
         req.add_field('Authorization', a)
 
         req.body = JSON.dump(
           grant_type: 'password', username: cs.user, password: cs.pass)
 
-        res = request(req)
-        #pp res
+        res = make_http(u).request(req)
+
+        Sentofu::Token.new(res)
+      end
+
+      def get(uri, token=nil)
+
+        u = URI(uri)
+
+#t0 = Time.now
+        res = make_http(u).request(make_get_req(u, token))
+        #def res.headers; r = {}; each_header { |k, v| r[k] = v }; r; end
+#puts "*** GET #{uri} took #{Time.now - t0}s"
 
-        OpenStruct.new(JSON.parse(res.body))
+        res
+      end
+
+      def get_and_parse(uri, token=nil)
+
+        JSON.parse(get(uri, token).body)
       end
 
       protected
 
-      def request(req)
+      def make_http(uri)
 
-        t = Net::HTTP.new(HOST, 443)
-        t.use_ssl = true
-        #t.verify_mode = OpenSSL::SSL::VERIFY_NONE # avoid
+#p uri.to_s
+        t = Net::HTTP.new(uri.host, uri.port)
+        t.use_ssl = (uri.scheme == 'https')
+#t.set_debug_output($stdout) if uri.to_s.match(/search/)
 
-        t.request(req)
+        t
+      end
+
+      def make_get_req(uri, token)
+
+        req = Net::HTTP::Get.new(uri.to_s)
+        req.instance_eval { @header.clear }
+        def req.set_header(k, v); @header[k] = [ v ]; end
+
+        req.set_header('User-Agent', Sentofu.user_agent)
+        req.set_header('Accept', 'application/json')
+
+        req.set_header('Authorization', token.header_value) if token
+#pp req.instance_variable_get(:@header)
+
+        req
       end
 
       def narrow_credentials(o)
@@ -55,5 +87,24 @@ module Sentofu
       end
     end
   end
+
+  class Token
+
+    def initialize(res)
+
+      @h = JSON.parse(res.body)
+      @expires_at = Time.now + @h['expires_in']
+    end
+
+    def not_expired?
+
+      Time.now < @expires_at
+    end
+
+    def header_value
+
+      'Bearer ' + @h['access_token']
+    end
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sentofu
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-18 00:00:00.000000000 Z
+date: 2019-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -37,6 +37,7 @@ files:
 - README.md
 - lib/sentofu.rb
 - lib/sentofu/api.rb
+- lib/sentofu/explo.rb
 - lib/sentofu/http.rb
 - sentofu.gemspec
 homepage: http://github.com/jmettraux/sentofu