lexicon-common 0.1.0 → 0.2.0

data/lib/lexicon/common/psql.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lexicon
+  module Common
+    class Psql
+      # @param [String] url
+      # @param [ShellExecutor] executor
+      def initialize(url:, executor:)
+        @url = url
+        @executor = executor
+      end
+
+      # @param [String] command
+      # @param [String, Array<String>] search_path
+      def execute(command, search_path:)
+        command = <<~SQL
+          SET search_path TO #{Array(search_path).join(', ')};
+          #{command}
+        SQL
+
+        execute_raw(command)
+      end
+
+      # @param [String] command
+      def execute_raw(command)
+        @executor.execute <<~BASH
+          psql '#{url}' --quiet -c #{Shellwords.escape(command)}
+        BASH
+      end
+
+      # @param [Pathname] file
+      # @param [String, Array<String>] search_path
+      def load_sql(file, search_path:)
+        @executor.execute <<~BASH
+          echo 'SET SEARCH_PATH TO #{Array(search_path).join(', ')};' | cat - #{file} | psql '#{url}'
+        BASH
+      end
+
+      private
+
+        # @return [ShellExecutor]
+        attr_reader :executor
+        # @return [String]
+        attr_reader :url
+    end
+  end
+end

data/lib/lexicon/common/remote/package_downloader.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Corindon::Result::Ext
+
 module Lexicon
   module Common
     module Remote
@@ -9,71 +11,87 @@ module Lexicon
         # @param [DirectoryPackageLoader] package_loader
         def initialize(s3:, out_dir:, package_loader:)
           super(s3: s3)
+
           @out_dir = out_dir
           @package_loader = package_loader
         end
 
         # @param [Semantic::Version] version
-        # @return [Boolean]
+        # @return [Corindon::Result::Result]
         def download(version)
-          bucket = version.to_s
+          rescue_failure do
+            bucket = version.to_s
 
-          if s3.bucket_exist?(bucket)
-            Dir.mktmpdir(nil, out_dir) do |tmp_dir|
-              tmp_dir = Pathname.new(tmp_dir)
+            if s3.bucket_exist?(bucket)
+              Dir.mktmpdir(nil, out_dir) do |tmp_dir|
+                tmp_dir = Pathname.new(tmp_dir)
 
-              s3.raw.get_object(
-                bucket: bucket,
-                key: Package::Package::SPEC_FILE_NAME,
-                response_target: tmp_dir.join(Package::Package::SPEC_FILE_NAME).to_s
-              )
-              s3.raw.get_object(
-                bucket: bucket,
-                key: Package::Package::CHECKSUM_FILE_NAME,
-                response_target: tmp_dir.join(Package::Package::CHECKSUM_FILE_NAME).to_s
-              )
+                download_spec_files(bucket, tmp_dir).unwrap!
 
-              package = package_loader.load_package(tmp_dir.basename.to_s)
-              if !package.nil?
-                puts "[  OK ] Found package with key #{version}, version is #{package.version}".green
+                package = package_loader.load_package(tmp_dir.basename.to_s)
+                if !package.nil?
+                  puts "[  OK ] Found package with key #{version}, version is #{package.version}".green
 
-                FileUtils.mkdir_p package.data_dir
+                  download_data_files(package, bucket).unwrap!
 
-                package.structure_files.map do |file|
-                  Thread.new do
-                    s3.raw.get_object(bucket: bucket, key: "data/#{file.basename.to_s}", response_target: file.to_s)
-                    puts "[  OK ] Downloaded #{file.basename}".green
-                  end
-                end.each(&:join)
+                  dest_dir = out_dir.join(version.to_s)
+                  FileUtils.mkdir_p(dest_dir)
 
-                package.file_sets.map do |fs|
-                  Thread.new do
-                    path = package.data_path(fs)
-                    s3.raw.get_object(bucket: bucket, key: "data/#{path.basename.to_s}", response_target: path.to_s)
-                    puts "[  OK ] Downloaded #{path.basename}".green
+                  tmp_dir.children.each do |child|
+                    FileUtils.mv(child.to_s, dest_dir.join(child.basename).to_s)
                   end
-                end.each(&:join)
-
-                dest_dir = out_dir.join(version.to_s)
-                FileUtils.mkdir_p(dest_dir)
-                tmp_dir.children.each do |child|
-                  FileUtils.mv(child.to_s, dest_dir.join(child.basename).to_s)
-                end
 
-                true
-              else
-                puts "[ NOK ] The remote contains a bucket '#{version}' but it does not contains a valid package.".red
+                  Success(package)
+                else
+                  puts "[ NOK ] The remote contains a bucket '#{version}' but it does not contains a valid package.".red
 
-                false
+                  Failure(StandardError.new("The folder #{bucket} on the server does not contain a valid package"))
+                end
               end
+            else
+              Failure(StandardError.new("The server does not have a directory named #{bucket}"))
             end
-          else
-            false
           end
         end
 
         private
 
+          def download_data_files(package, bucket)
+            rescue_failure do
+              threads = package.files.map do |file|
+                Thread.new do
+                  destination = package.dir.join(file.path)
+                  FileUtils.mkdir_p(destination.dirname)
+
+                  s3.raw.get_object(bucket: bucket, key: file.to_s, response_target: destination)
+
+                  puts "[  OK ] Downloaded #{file}".green
+                end
+              end
+
+              threads.each(&:join)
+
+              Success(nil)
+            end
+          end
+
+          def download_spec_files(bucket, tmp_dir)
+            rescue_failure do
+              s3.raw.get_object(
+                bucket: bucket,
+                key: Package::Package::SPEC_FILE_NAME,
+                response_target: tmp_dir.join(Package::Package::SPEC_FILE_NAME).to_s
+              )
+              s3.raw.get_object(
+                bucket: bucket,
+                key: Package::Package::CHECKSUM_FILE_NAME,
+                response_target: tmp_dir.join(Package::Package::CHECKSUM_FILE_NAME).to_s
+              )
+
+              Success(nil)
+            end
+          end
+
           # @return [DirectoryPackageLoader]
           attr_reader :package_loader
           # @return [Pathname]

data/lib/lexicon/common/remote/package_uploader.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+using Corindon::Result::Ext
+
 module Lexicon
   module Common
     module Remote
@@ -7,51 +9,58 @@ module Lexicon
         include Mixin::LoggerAware
 
         # @param [Package] package
-        # @return [Boolean]
+        # @return [Corindon::Result::Result]
         def upload(package)
-          bucket_name = package.version.to_s
-          if !s3.bucket_exist?(bucket_name)
-            s3.create_bucket(bucket: bucket_name)
-            puts 'Uploading structures...'
+          rescue_failure do
+            bucket_name = package.version.to_s
+
+            if s3.bucket_exist?(bucket_name)
+              Failure(StandardError.new("The server already has a folder named #{bucket_name}"))
+            else
+              upload_package(package, bucket_name)
+            end
+          end
+        end
 
-            upload_files(*package.structure_files, bucket: bucket_name, prefix: 'data')
-            puts '[  OK ] Structure uploaded.'.green
+        private
 
-            data_files = package.file_sets
-                                .select(&:data_path)
-                                .map { |fs| package.data_path(fs) }
+          # @return [Corindon::Result::Result]
+          def upload_package(package, bucket_name)
+            s3.raw.create_bucket(bucket: bucket_name)
 
-            upload_files(*data_files, bucket: bucket_name, prefix: 'data') do |path|
-              puts "[  OK ] #{path.basename}".green
-            end
+            relative_paths = [*base_files, *package.files.map(&:path)]
 
-            upload_files(package.checksum_file, package.spec_file, bucket: bucket_name) do |path|
+            upload_files(*relative_paths, from: package.dir, bucket: bucket_name) do |path|
               puts "[  OK ] #{path.basename}".green
             end
 
-            true
-          else
-            false
-          end
-        rescue StandardError => e
-          log_error(e)
-
-          false
-        end
+            Success(package)
+          rescue StandardError => e
+            s3.ensure_bucket_absent(bucket_name)
 
-        private
+            Failure(e)
+          end
 
           # @param [Array<Pathname>] files
-          #
+          # @param [Pathname] from
           # @yieldparam [Pathname] path
-          def upload_files(*files, bucket:, prefix: nil)
+          def upload_files(*files, bucket:, from:)
             files.each do |path|
-              path.open do |f|
-                s3.put_object(bucket: bucket, key: [prefix, path.basename.to_s].compact.join('/'), body: f)
+              from.join(path).open do |f|
+                s3.raw.put_object(bucket: bucket, key: path.to_s, body: f)
               end
+
               yield path if block_given?
             end
           end
+
+          # @return [Array<Pathname>]
+          def base_files
+            [
+              Pathname.new(Package::Package::CHECKSUM_FILE_NAME),
+              Pathname.new(Package::Package::SPEC_FILE_NAME),
+            ]
+          end
       end
     end
   end

data/lib/lexicon/common/remote/s3_client.rb

@@ -31,6 +31,12 @@ module Lexicon
           false
         end
 
+        # @param [String] name
+        def ensure_bucket_absent(name)
+          if bucket_exist?(name)
+            raw.delete_bucket(bucket: name)
+          end
+        end
       end
     end
   end

data/lib/lexicon/common/schema/validator_factory.rb

@@ -9,7 +9,7 @@ module Lexicon
           @schema_path = schema_path
         end
 
-        # @return [JSONSchemer::Schema]
+        # @return [JSONSchemer::Schema::Base]
         def build
           JSONSchemer.schema(schema_path)
         end

data/lib/lexicon/common/shell_executor.rb

@@ -4,7 +4,6 @@ module Lexicon
   module Common
     class ShellExecutor
       include Mixin::Finalizable
-      include Mixin::LoggerAware
 
       def initialize
         @command_dir = Dir.mktmpdir
@@ -13,8 +12,6 @@ module Lexicon
       # @param [String] command
       # @return [String]
       def execute(command)
-        log(command.cyan)
-
         cmd = Tempfile.new('command-', @command_dir)
         cmd.write <<~BASH
           #!/usr/bin/env bash

data/lib/lexicon/common/version.rb

@@ -1,5 +1,5 @@
 module Lexicon
   module Common
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/resources/lexicon.schema.json

@@ -5,47 +5,132 @@
   "description": "",
   "type": "object",
   "properties": {
+    "schema_version": {
+      "$ref": "#/definitions/schema_versions"
+    },
     "version": {
+      "$ref": "#/definitions/semver"
+    }
+  },
+  "oneOf": [
+    {
+      "properties": {
+        "schema_version": {
+          "type": "integer",
+          "const": 1
+        },
+        "content": {
+          "$ref": "#/definitions/content/1"
+        }
+      }
+    },
+    {
+      "properties": {
+        "schema_version": {
+          "type": "integer",
+          "const": 2
+        },
+        "content": {
+          "$ref": "#/definitions/content/2"
+        }
+      }
+    }
+  ],
+  "required": [
+    "version",
+    "content"
+  ],
+  "definitions": {
+    "schema_versions": {
+      "type": "integer",
+      "default": 2,
+      "enum": [
+        2
+      ]
+    },
+    "semver": {
       "description": "The version of the packaged version",
       "type": "string",
       "$comment": "Regex is from https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string",
       "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$"
     },
     "content": {
-      "type": "object",
-      "patternProperties": {
-        "^[a-z][a-z_]*$": {
-          "type": "object",
-          "properties": {
-            "name": {
-              "type": "string"
-            },
-            "structure": {
-              "type": "string"
-            },
-            "data": {
-              "type": "string"
+      "1": {
+        "type": "object",
+        "patternProperties": {
+          "^[a-z][a-z_]*$": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "structure": {
+                "type": "string"
+              },
+              "data": {
+                "type": "string"
+              },
+              "tables": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "additionalItems": false
+              }
             },
-            "tables": {
-              "type": "array",
-              "items": {
+            "required": [
+              "name",
+              "structure",
+              "tables"
+            ]
+          }
+        },
+        "additionalProperties": false
+      },
+      "2": {
+        "type": "object",
+        "patternProperties": {
+          "^[a-z][a-z_]*$": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "structure": {
                 "type": "string"
               },
-              "additionalItems": false
-            }
-          },
-          "required": [
-            "name",
-            "structure",
-            "tables"
-          ]
+              "tables": {
+                "type": "object",
+                "patternProperties": {
+                  "^([a-z]+)(_[a-z]+)*$": {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    },
+                    "additionalItems": false
+                  }
+                },
+                "additionalProperties": false
+              }
+            },
+            "required": [
+              "name",
+              "structure",
+              "tables"
+            ]
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "versions": {
+      "default": {
+        "properties": {
+          "content": {
+            "$ref": "#/definitions/content/1"
+          }
         }
-      },
-      "additionalProperties": false
+      }
     }
-  },
-  "required": [
-    "version",
-    "content"
-  ]
+  }
 }