forest_admin_agent 1.2.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a56a37cdfd7ed783868dbca000d0c4deb0ab3bfb90707d5ed1cbaa7172e60787
-  data.tar.gz: f9ef8417a352bca6ec087531e76c1133ad5e808ce14204e5a3c764a168505ab7
+  metadata.gz: fd1bd4933a670f98f7eb6ab7be5f9c07d5a8606e036b5291ccdb2f4ccc63f244
+  data.tar.gz: 22351053a83ac8408274d5bc3db73ebaa340539c2282cd505823a54af3749918
 SHA512:
-  metadata.gz: 42469893d26c088d2f90b776908d27d706202014db2b7720b3a9c5bef07abfe7b8197e9378107e61b023017545b55518d0a34903f88583cbecef14fdc82b34b4
-  data.tar.gz: d7e77d8159fdd8a00b1f5f87e365ecaf57dbd3686d82402d0e4afe4545b7f891a8534186c1065cecdd2fb57a434a9d05f2fb45c9c9e91a08c8a8f9dd2589b202
+  metadata.gz: 36ef8ee8a25b96a39899d71aed9600b66098a31715453208563fae25b01a59fb306deeb4fb8734898f47a50bbd5ba74cb359e6807cc9153cc42203a3c4dda38b
+  data.tar.gz: 00e081ae18380f0dcdb589221af21eb0095f4973c3e697b23b2d22db7a1f9f960443e1cfa9758ff762a6ae166b6825cd6312e6bd7e16d671f7d82b489e5e84bb

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/utils/schema/schema_emitter.rb

@@ -6,104 +6,69 @@ module ForestAdminAgent
     module Schema
       class SchemaEmitter
         LIANA_NAME = "agent-ruby"
+        LIANA_VERSION = "1.4.0"
 
-        LIANA_VERSION = "1.2.2"
-
-        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.2"
+  VERSION = "1.4.0"
 end

metadata

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