forest_admin_agent 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 003b5794d0fe2ed43b703cbcb42fa042007533c9437fdb4490ecea7a66d38e93
-  data.tar.gz: 447548e96498ec5393edc1d4c9620b1ceefb58f90e367040afb93971bfd2cd2e
+  metadata.gz: da8a8b740883c3c1ec638f1751ea49b801a1c558a92f900c9b3f22360f66410c
+  data.tar.gz: f12e6b0fb89390576841467edf90a825fbeae079198d3b19b6099e311fbc05f6
 SHA512:
-  metadata.gz: 30c15c87c87e621428615cd99af9791f37a42184a9a5e5f1900b071765fe35c2d90057077a8f91ee2323d89bcb95d27f3fd85df97873959e667d772cc5865019
-  data.tar.gz: ad3e5631354565adaa1c2989219f4a993567ad942f2ef199c229a0be476e80be38fa07f597ec064bea3bba28828976a9f441d0a98ded332c6a2423a2a20e7768
+  metadata.gz: '008e1c6e1b6df55fbdd977ef91d1b028c28d74c43e9e2fb4223ceb266ba742625b23c248746875270e0330542146035cf359abe2860177ae6cd649ae1535fc3d'
+  data.tar.gz: 1831488afd41a4ef2d390ca1f12c4b559f710ffa88afd7c3ebc684794c7b1cc7fdeda43cd5055a4c90fe9138eb367ec5a06aa6f09f1fdf156f08c732b8a27711

data/lib/forest_admin_agent/builder/agent_factory.rb

@@ -1,12 +1,14 @@
 require 'dry-container'
 require 'filecache'
+require 'json'
 
 module ForestAdminAgent
   module Builder
     class AgentFactory
       include Singleton
+      include ForestAdminAgent::Utils::Schema
+      include ForestAdminDatasourceToolkit::Exceptions
 
-      TTL_CONFIG = 3600
       TTL_SCHEMA = 7200
 
       attr_reader :customizer, :container, :has_env_secret
@@ -62,16 +64,50 @@ module ForestAdminAgent
       def send_schema(force: false)
         return unless @has_env_secret
 
-        schema = ForestAdminAgent::Utils::Schema::SchemaEmitter.get_serialized_schema(@container.resolve(:datasource))
-        schema_is_know = @container.key?(:schema_file_hash) &&
-                         @container.resolve(:schema_file_hash).get('value') == schema[:meta][:schemaFileHash]
+        schema_path = Facades::Container.cache(:schema_path)
 
-        if !schema_is_know || force
+        if Facades::Container.cache(:is_production)
+          unless schema_path && File.exist?(schema_path)
+            raise ForestException, "Can't load #{schema_path}. Providing a schema is mandatory in production."
+          end
+
+          schema = JSON.parse(File.read(schema_path), symbolize_names: true)
+        else
+          generated = SchemaEmitter.generate(@container.resolve(:datasource))
+          meta = SchemaEmitter.meta
+
+          schema = {
+            meta: meta,
+            collections: generated
+          }
+
+          File.write(schema_path, JSON.pretty_generate(schema))
+        end
+
+        if (append_schema_path = Facades::Container.cache(:append_schema_path))
+          begin
+            append_schema_file = JSON.parse(File.read(append_schema_path), symbolize_names: true)
+            schema[:collections] = schema[:collections] + append_schema_file[:collections]
+          rescue StandardError => e
+            raise "Can't load additional schema #{append_schema_path}: #{e.message}"
+          end
+        end
+
+        post_schema(schema, force)
+      end
+
+      private
+
+      def post_schema(schema, force)
+        api_map = SchemaEmitter.serialize(schema)
+        should_send = do_server_want_schema(api_map[:meta][:schemaFileHash])
+
+        if should_send || force
           client = ForestAdminAgent::Http::ForestAdminApiRequester.new
-          client.post('/forest/apimaps', schema.to_json)
+          client.post('/forest/apimaps', api_map.to_json)
           schema_file_hash_cache = FileCache.new('app', @options[:cache_dir].to_s, TTL_SCHEMA)
           schema_file_hash_cache.get_or_set 'value' do
-            schema[:meta][:schemaFileHash]
+            api_map[:meta][:schemaFileHash]
           end
           @container.register(:schema_file_hash, schema_file_hash_cache)
           ForestAdminAgent::Facades::Container.logger.log('Info', 'schema was updated, sending new version')
@@ -81,7 +117,19 @@ module ForestAdminAgent
         end
       end
 
-      private
+      def do_server_want_schema(hash)
+        client = ForestAdminAgent::Http::ForestAdminApiRequester.new
+
+        begin
+          response = client.post('/forest/apimaps/hashcheck', { schemaFileHash: hash }.to_json)
+          body = JSON.parse(response.body)
+          body['sendSchema']
+        rescue JSON::ParserError
+          raise ForestException, "Invalid JSON response from ForestAdmin server #{response.body}"
+        rescue Faraday::Error => e
+          client.handle_response_error(e)
+        end
+      end
 
       def build_container
         @container = Dry::Container.new

data/lib/forest_admin_agent/http/Exceptions/authentication_open_id_client.rb

@@ -2,10 +2,9 @@ module ForestAdminAgent
   module Http
     module Exceptions
       class AuthenticationOpenIdClient < HttpException
-        def initialize(status = 401,
-                       message = 'Authentication failed with OpenID Client',
+        def initialize(message = 'Authentication failed with OpenID Client',
                        name = 'AuthenticationOpenIdClient')
-          super
+          super(401, message, name)
         end
       end
     end

data/lib/forest_admin_agent/http/Exceptions/not_found_error.rb

@@ -1,13 +1,9 @@
 module ForestAdminAgent
   module Http
     module Exceptions
-      class NotFoundError < StandardError
-        attr_reader :name, :status
-
-        def initialize(msg, name = 'NotFoundError')
-          super(msg)
-          @name = name
-          @status = 404
+      class NotFoundError < HttpException
+        def initialize(message, name = 'NotFoundError')
+          super(404, message, name)
         end
       end
     end

data/lib/forest_admin_agent/routes/security/authentication.rb

@@ -42,9 +42,8 @@ module ForestAdminAgent
 
         def handle_authentication_callback(args = {})
           if args[:params].key?(:error)
-            raise AuthenticationOpenIdClient.new(args[:params][:state],
-                                                 args[:params][:error],
-                                                 args[:params][:error_description])
+            raise AuthenticationOpenIdClient.new(args[:params][:error_description] || args[:params][:error],
+                                                 args[:params][:error])
           end
 
           if args.dig(:headers, 'action_dispatch.remote_ip')

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -6,104 +6,69 @@ module ForestAdminAgent
     module Schema
       class SchemaEmitter
         LIANA_NAME = "agent-ruby"
+        LIANA_VERSION = "1.3.0"
 
-        LIANA_VERSION = "1.2.1"
-
-        def self.get_serialized_schema(datasource)
-          schema_path = Facades::Container.cache(:schema_path)
-          if Facades::Container.cache(:is_production)
-            schema = if schema_path && File.exist?(schema_path)
-                       JSON.parse(File.read(schema_path), { symbolize_names: true })
-                     else
-                       ForestAdminAgent::Facades::Container.logger.log(
-                         'Warn',
-                         'The .forestadmin-schema.json file doesn\'t exist'
-                       )
-
-                       {
-                         meta: meta(Digest::SHA1.hexdigest('')),
-                         collections: {}
-                       }
-                     end
-          else
-            schema = generate(datasource)
-            hash = Digest::SHA1.hexdigest(schema.to_json)
-            schema = {
-              meta: meta(hash),
-              collections: schema
-            }
-
-            File.write(schema_path, JSON.pretty_generate(schema))
-          end
-
-          serialize(schema)
+        def self.generate(datasource)
+          datasource.collections
+                    .map { |_name, collection| GeneratorCollection.build_schema(collection) }
+                    .sort_by { |collection| collection[:name] }
         end
 
-        class << self
-          private
-
-          def generate(datasource)
-            datasource.collections
-                      .map { |_name, collection| GeneratorCollection.build_schema(collection) }
-                      .sort_by { |collection| collection[:name] }
-          end
-
-          def meta(hash)
-            {
-              liana: LIANA_NAME,
-              liana_version: LIANA_VERSION,
-              stack: {
-                engine: 'ruby',
-                engine_version: RUBY_VERSION
-              },
-              schemaFileHash: hash
+        def self.meta
+          {
+            liana: LIANA_NAME,
+            liana_version: LIANA_VERSION,
+            stack: {
+              engine: 'ruby',
+              engine_version: RUBY_VERSION
             }
-          end
-
-          def serialize(schema)
-            data = []
-            included = []
-            schema[:collections].each do |collection|
-              collection_actions = collection[:actions]
-              collection_segments = collection[:segments]
-
-              collection.delete(:actions)
-              collection.delete(:segments)
-
-              included << get_smart_features_by_collection('actions', collection_actions, with_attributes: true)
-              included << get_smart_features_by_collection('segments', collection_segments, with_attributes: true)
+          }
+        end
 
-              data.push(
-                {
-                  id: collection[:name],
-                  type: 'collections',
-                  attributes: collection,
-                  relationships: {
-                    actions: { data: get_smart_features_by_collection('actions', collection_actions) },
-                    segments: { data: get_smart_features_by_collection('segments', collection_segments) }
-                  }
+        def self.serialize(schema)
+          hash = Digest::SHA1.hexdigest(schema[:collections].to_json)
+          data = []
+          included = []
+          schema[:collections].each do |collection|
+            collection_actions = collection[:actions]
+            collection_segments = collection[:segments]
+
+            collection.delete(:actions)
+            collection.delete(:segments)
+
+            included << get_smart_features_by_collection('actions', collection_actions, with_attributes: true)
+            included << get_smart_features_by_collection('segments', collection_segments, with_attributes: true)
+
+            data.push(
+              {
+                id: collection[:name],
+                type: 'collections',
+                attributes: collection,
+                relationships: {
+                  actions: { data: get_smart_features_by_collection('actions', collection_actions) },
+                  segments: { data: get_smart_features_by_collection('segments', collection_segments) }
                 }
-              )
-            end
-
-            {
-              data: data,
-              included: included.reject!(&:empty?)&.flatten || [],
-              meta: schema[:meta]
-            }
+              }
+            )
           end
 
-          def get_smart_features_by_collection(type, data, with_attributes: false)
-            smart_features = []
+          {
+            data: data,
+            included: included.reject!(&:empty?)&.flatten || [],
+            meta: schema[:meta].merge(schemaFileHash: hash)
+          }
+        end
 
-            data.each do |value|
-              smart_feature = { id: value[:id], type: type }
-              smart_feature[:attributes] = value if with_attributes
-              smart_features << smart_feature
-            end
+        def self.get_smart_features_by_collection(type, data, with_attributes: false)
+          smart_features = []
 
-            smart_features
+          data.each do |value|
+            smart_feature = { id: value[:id], type: type }
+            smart_feature[:attributes] = value if with_attributes
+            smart_features << smart_feature
           end
+
+          smart_features
         end
       end
     end

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Matthieu